Teknologian jakaminen

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

lineaarinen taulukko

haluamme puhuaSekvenssitaulukko, meidän on ensin puhuttava lineaarisista taulukoista, koska peräkkäiset taulukot ovat eräänlaisia ​​lineaarisia taulukoita.

Lineaarisen taulukon määritelmä

Kuten nimestä voi päätellä, lineaarinen taulukko on taulukko, joka järjestää tiedot kuten rivit.
Sen voi ymmärtää ajattelemalla jonotusta todellisuudessa.

Lineaaristen taulukoiden ominaisuudet:

• Lineaarisen taulukon tietoelementtien välillä on järjestys.
• Ensimmäistä ja viimeistä elementtiä lukuun ottamatta jokaisella elementillä on edeltäjä ja seuraaja.

Sekvenssitaulukko

Järjestystaulukko on kappaleFyysiset osoitteet ovat peräkkäisiäSäilytysyksiköt ovat kuin ihmisiä, jotka asettuvat vierekkäin.
Lineaarinen rakenne, joka tallentaa tietoelementit järjestyksessä, yleensä käyttäenjoukkovarastointi.
Suorita taulukon tietojen lisääminen, poistaminen, tarkistaminen ja muokkaaminen.

Sekvenssitaulukkorajapinnan toteutus

Toteuta itse sekvenssitaulukko (storage int type data), käytä sekvenssitaulukkoa luokkana, toteutamme joitain rajapintoja, eli joitainjäsenmenetelmäToteuttaa tietojen lisääminen, poistaminen, tarkistaminen ja muuttaminen.

public class SeqList {
     private int[] elem;
     private int usedSize;
     // 默认构造方法
     SeqList(){   }
     // 将顺序表的底层容量设置为initcapacity
     SeqList(int initcapacity){   }
     // 新增元素,默认在数组最后新增
     public void add(int data) { }
     // 在 pos 位置新增元素
     public void add(int pos, int data) { }
     // 判定是否包含某个元素
     public boolean contains(int toFind) { return true; }
     // 查找某个元素对应的位置
     public int indexOf(int toFind) { return -1; }
     // 获取 pos 位置的元素
     public int get(int pos) { return -1; }
     // 给 pos 位置的元素设为 value
     public void set(int pos, int value) {   }
     //删除第一次出现的关键字key
     public void remove(int toRemove) {   }
     // 获取顺序表长度
     public int size() { return 0; }
     // 清空顺序表
     public void clear() {   }
     
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

Oletuskonstruktori

Oletuksena avaamme aluksi 10 tietotilaa.

private static final int DEFAULT_SIZE = 10;
    public SeqList() {
        this.elem= new int[DEFAULT_SIZE];
    }
1
2
3
4

Aseta sekvenssitaulukon taustalla oleva kapasiteetti arvoon initcapacity

Anna taulukon pituus ja käytä taulukon pituutta tilan avaamiseen.

private static final int DEFAULT_SIZE = 10;
    public SeqList(int initcapacity) {
        this.elem= new int[initcapacity];
    }
1
2
3
4

häntätulppa

Uudet elementit lisätään oletuksena taulukon loppuun.
Huomioitavaa:

• Tarkista, onko nykyinen järjestystaulukko täynnä, jos se on täynnä, lisää tilaa.
• Elementti lisätään ja UseSize kasvaa yhdellä.

 public void add(int data) {
        if(isFull()){
            elem = Arrays.copyOf(elem,elem.length * 2);
        }
        elem[usedSize++] = data;
    }
     /**
     * 判断当前的顺序表是不是满的！
     *
     * @return true:满   false代表空
     */
    private boolean isFull() {
        return usedSize == elem.length;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Lisää elementti positioon

Lisää elementti pos-alaindeksiin.
Varotoimenpiteet:

• Tarkista, onko nykyinen järjestystaulukko täynnä, jos se on täynnä, lisää tilaa.
• Tarkista, onko annettu positio laillinen Jos se ei ole laillinen, tehdään poikkeus.
• Käytä taka-eteen-silmukkaa siirtääksesi elementtejä pos-asennon jälkeen taaksepäin.
• Elementti lisätään ja UseSize kasvaa yhdellä.

private boolean checkPosInAdd(int pos) throws PosIllegalException{

        if(pos < 0 || pos > usedSize){
            throw new PosIllegalException("位置不合法");
        }
        return true;
    }

    // 在 pos 位置新增元素
    public void add(int pos, int data) {
        try{
            if(checkPosInAdd(pos)){
                if(isFull()){
                    elem = Arrays.copyOf(elem,elem.length * 2);
                }
                for (int i = usedSize; i > pos ; i--) {
                    elem[i] = elem[i-1];
                }
                elem[pos] = data;
                usedSize++;
            }
        }catch(PosIllegalException e){
            e.printStackTrace();
        }

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

Selvitä, sisältyykö elementti

Katso, onko annetut tiedot sisällytetty järjestystaulukkoon.
Selaa sitä suoraan, palauta tosi, jos löydät sen, ja palauta false, jos et löydä.

public boolean contains(int toFind) {
        for (int i = 0; i < usedSize; i++) {
            if(elem[i] == toFind){
                return true;
            }
        }
        return false;
    }
1
2
3
4
5
6
7
8

Etsi elementtiä vastaava sijainti

Katso annettujen tietojen indeksiä tästä järjestystaulukosta.
Selaa suoraan läpi ja löydä paluuindeksi ilman -1:n palautusta.

public int indexOf(int toFind) {
        for (int i = 0; i < usedSize; i++) {
            if(elem[i] == toFind){
                return i;
            }
        }
        return -1;
    }
1
2
3
4
5
6
7
8

Ota elementti positioon

Tulosta elementti positioon.
Varotoimenpiteet:

• Tarkista, onko käyttöoikeus laillinen

public int get(int pos) {
        try{
            if(checkPosInAdd(pos)){
                return elem[pos];
            }
        }catch(PosIllegalException e){
            e.printStackTrace();
        }
        return 0;
    }
1
2
3
4
5
6
7
8
9
10

Aseta elementti kohtaan pos arvoon

Muokkaa pos position -elementtiä.
Varotoimenpiteet:

• Tarkista, onko käyttöoikeus laillinen.

public void set(int pos, int value) {
        try{
            if(checkPosInAdd(pos)){
                elem[pos] = value;
            }
        }catch(PosIllegalException e){
            e.printStackTrace();
        }
    }
1
2
3
4
5
6
7
8
9

Poista avainsanaavaimen ensimmäinen esiintymä

Poista avaimen ensimmäinen esiintymä.
Varotoimenpiteet:

• Selaa hakua.
• Käytä löydetyn avaimen jälkeisiä elementtejä peittääksesi ne yksitellen eteenpäin.
• käytettyKoko pienenee 1.

public void remove(int key) {
        for (int i = 0; i < usedSize; i++) {
            if(elem[i] == key){
                for (int j = i; j < usedSize - 1; j++) {
                    elem[j] = elem[j + 1];
                }
                usedSize--;
            }
        }
    }
1
2
3
4
5
6
7
8
9
10

Hanki sekvenssitaulukon pituus

Sekvenssitaulukon pituuden saaminen viittaa tässä hyödyllisten tietojen määrään, eli usedSizeen.

public int size() {
        return usedSize;
    }
1
2
3

Tyhjennä sekvenssiluettelo

Aseta sekvenssitaulukon sisältö tyhjäksi.
Varotoimenpiteet:

• Koska todellinen peräkkäinen taulukko tallentaa yleiset tiedot, elementit asetetaan tyhjiksi, kun ne kuljetetaan yksitellen, ja korvataan asettamalla ne arvoon 0 alla.
• UsedSize on myös asetettu arvoon 0.

public void clear() {
        for (int i = 0; i < usedSize; i++) {
            elem[i] = 0;
        }
        usedSize = 0;
    }
1
2
3
4
5
6

ArrayList Javassa

ArrayList-luokka tarjotaan Javassa edustamaan peräkkäistä luetteloa.

toteutettu käyttöliittymä

Käyttöliittymän kuvaus:

1. RandomAccess-käyttöliittymä ilmaisee satunnaiskäytön tuen.
2. Kloonattava käyttöliittymä osoittaa tuen kloonaukselle.
3. Serialisoitava käyttöliittymä ilmaisee serialisoinnin tuen.

Rakennusmenetelmä

Java tarjoaa kolme rakennusmenetelmää taulukon mukaisesti:

Yleisiä menetelmiä

Tarjotut yleiset menetelmät ovat samanlaisia ​​kuin yllä otetut.

Sekvenssiluetteloiden edut ja haitat

etu

Sekvenssitaulukoiden edut ovat seuraavat:

1. Random access on tuettu.
2. Tietyn alaindeksin kysely on nopeaa.

puute

1. Jos tilaa ei ole tarpeeksi, sitä on laajennettava, jolloin muisti tuhlaa.
2. Lisääminen ja poistaminen otsikossa ja keskellä siirtää tietoja.

harjoitella

Alla linkit harjoituksiin:
Yang Huin kolmio