Structure de données Notes d'étude - Tableau

Il dispose d'un tableau de

• Les éléments de la matrice sont stockées séquentiellement dans la mémoire, table logique séquentielle
• La mémoire est l'une des unités de mémoire, chaque cellule de mémoire a sa propre adresse
• Après l'initialisation du réseau, un espace fixe
• indices Array commence à 0

complexité du temps

• Elément de matrice lu voie d'accès aléatoire: Array [3], quelle que soit la taille de la matrice d'entrée, et donc la complexité de temps est O (1)
• La mise à jour des éléments du tableau manière: array [3] = 10, quelle que soit la taille de la matrice d'entrée, la complexité en temps de O (1);
• élément de tableau est inséré, est inséré dans le pire groupement de tête possible, la totalité de l'indice de moût de réseau après un changement, la complexité en temps de O (n)
• Suppression des éléments de la matrice, le même principe d'éléments d'insertion, la complexité temporelle est O (n)

Nombre 组 démo

package com.cc.array;

public class MyArray {
    private int [] array;
    //数组的实际长度
    private int size;

    public MyArray(int capacity) {
        array=new int[capacity];
        size=0;
    }

    /**
     * 数组插入元素
     * @param index
     * @param element
     * @throws Exception
     */
    public void insert(int index,int element) throws Exception{
        if (index<0||index>size)
            throw new IndexOutOfBoundsException("数组下标越界！");
        //数组的实际长度大于数组容器的长度，对数组进行扩容
        if (size>=array.length)
            resize();
        //从右向左至插入位置，每个元素向右移动一位
        for (int i=size-1;i>=index;i--){
            array[i+1]=array[i];
        }
        //插入位置的元素为当前插入的元素
        array[index]=element;
        //数组的实际长度加1
        size++;
    }

    /**
     * 实现数组的扩容
     */
    public void resize(){
        //新数组的容器的长度在原来数组容器的长度上*2，实现扩容
        int [] newArray =new int[array.length*2];
        //数组复制,原数组，原数组复制的起位置，目标数组，目标数组的起始位置，复制的长度
        System.arraycopy(array,0,newArray,0,array.length);
        //实现长度扩容
        array=newArray;
    }

    /**
     * 数组输出
     */
    public void out(){
        for (int i = 0; i <array.length; i++) {
            System.out.println(array[i]);
        }
    }

    /**
     * 删除指定位置的元素
     * @param index
     * @return
     */
    public int delete(int index){
        if (index<0||index>=size)
            throw new IndexOutOfBoundsException("数组下标越界！");
        int deleteElement =array[index];
        //将后一个元素赋值给钱面一个元素，防止数组越界，i<size-1,因此array[i+1]才不会越界
        for(int i=index;i<size-1;i++){
            array[i]=array[i+1];
        }
        //将最后一个元素改为初始值0
        array[size-1]=0;
        //数组的实际长度减一
        size--;
        return deleteElement;
    }

    public static void main(String[] args) throws Exception {
        MyArray myArray =new MyArray(4);
        myArray.insert(0,1);
        myArray.insert(1,2);
        myArray.insert(2,3);
        myArray.insert(3,4);
        myArray.insert(4,25);
//        myArray.out();
        myArray.delete(1);
        myArray.out();

    }
}