Technology sharing

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

linearibus mensa

nos vis loquiSequentia mensaDe tabulis linearibus primo dicendum est, quod tabulae sequentes typum sunt tabularum linearium.

Definitio mensae linearis

Ut nomen sonat, mensa linearis est mensa quae notitias linearum ordinat.
Intelligi potest cogitando queuein in re.

Characteres tabularum linearium:

• Ordo est inter elementa datae tabulae linearis.
• Excepto primo elemento et ultimo, quodlibet elementum habet decessorem et successorem.

Sequentia mensa

Consequentia mensa utitur paragraphoOratio corporalis consecutiva suntUnitates repono sicut homines oblinit iuxta se.
A linearis structura quae dat elementa ordine addit, plerumque utensordinatarepono.
Perficere additionem, deletionem, recognitionem et modificationem notitiarum in ordine.

Exsequendam seriem mensam interface

Consequentiam tabulam te ipsum deduce (storage int type data), utere tabula sequentia ut genus, deducimus aliquid interfaces, id est, aliquas.membrum modumCognoscere additionem, deletionem, recognitionem et modificationem data.

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

Default conditor

Defalta initio X spatia notitiarum aperimus.

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

Constitue in mensa sequentia ad facultatem underlying initcapacity

Transi in longitudinem aciem et longitudinem utere aciem spatium aperire.

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

cauda obturaculum

Nova elementa in fine ordinata per defaltam addita sunt.
Puncta considerare;

• Perspicias num series currentis plena sit mensa.
• Elementum additur et uso 1 augetur.

 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

Addere elementum at pos loco

Inserere elementum at pos subscript.
Cautiones:

• Perspicias num series currentis plena sit mensa.
• Estne dati iuris pos- positio?
• Utere retrorsum-ad-ante loop ad movendum elementa post pos positionem retrorsum.
• Elementum additur et uso 1 augetur.

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

Utrum elementum contineatur

Vide an data notitia in tabula sequenti comprehendatur.
Modo ansam per illam directe, si inveneris veram redde, et falsa redde si non facis.

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

Reperio loco elementi respondentem

Vide indicem datarum hac seriei in tabula.
Modo ansam per directum et subscriptas reditus invenias sine reddendo -1.

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

Ut elementum at pos situ

Elementum output at pos position.
Cautiones:

• Reprehendo si pos est legalis

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

Constitue elementum in situ pos ad valorem

Positu elementum mitigare pos.
Cautiones:

• Reprehendo si pos legalis est.

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

Delere primum eventum keyword clavis

Primum eventum clavis dele.
Cautiones:

• Ansam per quaere.
• Utere elementis post clavem inventam ad ea singulatim ad frontem operiendum.
• usedSize I decrescat.

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

Accipere ordine mensam longitudinem

Adipiscendi longitudinem sequentis tabulae hic refertur ad numerum notitiarum utilium, id est, ususSize.

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

Patet series list

Sequentia tabulam pone contenta evacuare.
Cautiones:

• Quia tabulae sequentes reales traduntur generica, elementa vacua ponuntur singulatim percursa.
• Usus est etiam ad 0.

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

ArrayList in Java

Classis ArrayList providetur in Java ut album sequentem exprimat.

implemented interface

Interface Description:

1. RandomAccess interfacies indicat auxilium pro accessu temere.
2. Instrumentum cloneabile indicat firmamentum ad exquisitionem.
3. Interface Serializable subsidium serialization indicat.

Modus constructionis

Java 3 modi constructionem praebet ut in tabula exhibetur;

Modi communes

Communes modos praevisi sunt similes illis quae supra peragimus.

Commoda et Incommoda Sequentiae Album

commodum

Commoda tabularum sequentiarum sunt haec:

1. Aditus temere sustentatur.
2. Querying a dato subscriptum est velox.

defectus

1. Si spatium non est satis, amplietur oportet, et memoria superfluum erit.
2. Insertio et deletio in capite et medio data movebunt.

usu

Vincula ad exercitationes infra sunt:
Yang Hui triangulum