Estructura de Datos Estudio Notas - arsenal

Cuenta con una matriz de

• Elementos de la matriz se almacenan secuencialmente en la memoria, mesa lógicamente secuencial
• La memoria es una de las unidades de memoria, cada celda de memoria tiene su propio correo electrónico
• Después de la inicialización de la matriz, un espacio fijo
• índices de los arrays empiezan desde 0

complejidad del tiempo

• elemento de la matriz de lectura aleatoria vía de acceso: array [3], independientemente del tamaño de la matriz de entrada, y por lo tanto la complejidad de tiempo es O (1)
• Actualización de la manera elementos de la matriz: array [3] = 10, independientemente del tamaño de la matriz de entrada, el tiempo de complejidad de O (1);
• elemento de matriz se inserta, se inserta en el peor de array cabeza posible, todo el índice de matriz mosto después de un turno, el tiempo de complejidad de O (n)
• elementos Eliminar de la matriz, el mismo principio de elementos de inserción, complejidad de tiempo es O (n)

Número de demostración 组

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();

    }
}