数据结构与算法-动态数组

什么是数据结构

数据结构是计算机存储，组织数据的方式

• 线性结构：线性表（数组，链表，栈，列队，哈希表（数组））
• 树形结构：二叉树（AVL树，红黑树，B树，堆，Trie，哈夫曼树，并查集）
• 图形结构：邻接矩阵，邻接表

线性表

线性表是具有n个相同类型元素的有限序列（n>=0）
a1 是首节点（首元素），an是尾节点（尾元素）
a1是a2的前驱，a2是a1的后继

数组

数组是一种顺序存储的线性表，所有的元素的内存地址是连续的

int[] array =new int[]{11,22,33};

在很多编程中，数组都有个致命的缺点：无法动态修改容量
而实际开发中，我们更希望数组的容量可以动态改变的

动态数组

接口设计

int size();//元素的数量
boolean isEmpty();//是否为空
boolean contains(E element);//是否包含某个元素
void add(E element);//添加元素到最后面
E get(int index);//返回index位置对应的元素
E set(int index,E element);//设置index位置的元素
void add(int index,E element);//往index位置添加元素
E remove(int index);//删除index位置对应的元素
int indexOf(E element);//查看元素的位置
void clear();//清除所有元素

基本功能代码及实现

/**
 * @Author :Ersan
 * @Date 2020/10/27
 * @Description
 */
public class ArrayList {
    private int size; //元素的数量
    private int[] elements;//所有的元素
    private static final int DEFAULT_CAPACITY=10;
    private static final int ELEMENT_NOT_FOUND=-1;
    public ArrayList(int capaticy){
        capaticy=(capaticy<DEFAULT_CAPACITY)? DEFAULT_CAPACITY:capaticy;
        elements=new int[capaticy];
    }
    public ArrayList(){
        this(DEFAULT_CAPACITY);
    }
    /*
    *清除所有元素
    */
    public void clear(){
        size=0;
    }
    /*
    *元素的数量
    * return
    */
    public int size(){
        return size;
    }
    /*
     *是否为空
     * return
     */
    public boolean isEmpty(){
        return size==0;
    }
    /*
    *是否包含某个元素
    * param element
    * return
    */
    public  boolean contains(int element){
        return indexOf(element)!=ELEMENT_NOT_FOUND;
    }

    /*
    *添加元素到尾部
    * param element
    */
    public void add(int element){
        add(size,element);
    }

    /*
    *获取index位置的元素
    * param index
    * return
    */
    public int get(int index){
        rangeCheck(index);
        return elements[index];
    }

    /*
    *设置index位置的元素
    * param index
    * param element
    * return 原来的元素
    */
    public int set(int index,int element){
        rangeCheck(index);
        int old=elements[index];
        elements[index]=element;
        return old;
    }

    /*
    *在index位置插一个元素
    * param index
    * param element
    */
    public void add(int index,int element){
        rangeCheckForAdd(index);
        ensureCapacity(size + 1);//扩容

        for (int i= size-1;  i >= index ; i--) {
            elements[i+1]=elements[i];
        }
        elements[index]=element;
        size++;
    }

    /*
    *删除index位置的元素
    *param index
    * return
    */
    public int remove(int index){
        rangeCheck(index);
        int old=elements[index];
        for (int i = index + 1; i < size; i++) {
            elements[i-1]=elements[i];
        }
        size--;
        return old;
    }

    @Override
    public String toString() {
        StringBuffer string=new StringBuffer();
        string.append("size=").append(size).append(",  [");
        for (int i = 0; i < size; i++) {
            if (i!=0){
                string.append(", ");
            }
            string.append(elements[i]);

//            if (i!=size-1){
//                string.append(",");
//            }
        }
        string.append("]");
        return string.toString();
    }

    /*
    *查看元素的索引
    * param element
    * return
    */
    public int indexOf(int element){
        for (int i = 0; i < size; i++) {
            if (elements[i]==element) return i;
        }
        return ELEMENT_NOT_FOUND;
    }

    private void outOfBounds(int index){
        throw new IndexOutOfBoundsException("Index:"+index+", Size:"+size);
    }
    private void rangeCheck(int index){
        if (index<0||index>=size) {
            outOfBounds(index);
        }
    }
    private void rangeCheckForAdd(int index){
        if (index<0||index>size) {
            outOfBounds(index);
        }
    }
    //保证要有capacity的容量
    private void ensureCapacity(int capacity){
        int oldCapacity=elements.length;
        if (oldCapacity>=capacity) return;

        //新容量为旧容量的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        int[] newElements=new int[newCapacity];
        for (int i = 0; i < size; i++) {
            newElements[i]=elements[i];
        }
        elements=newElements;
    }
}

泛型

public class ArrayList<E> {
	private int size;
	private E[] elements;
	
	elements = (E[])new Object[capacity];
}

ArrayList<Integer> list = new ArrayList<>(); 

对象数组

数组存的是对象的地址

内存管理细节

    public void clear(){
        for (int i = 0; i < size; i++) {
            elements[i]=null;
        }
        size=0;
    }

    public E remove(int index){
        rangeCheck(index);
        E old=elements[index];
        for (int i = index + 1; i < size; i++) {
            elements[i-1]=elements[i];
        }
        elements[--size]=null;
        return old;
    }

null的处理

    public int indexOf(E element){
        if (element==null) {
            for (int i = 0; i < size; i++) {
                if (elements[i]==null) return i;
            }
        }else {

            for (int i = 0; i < size; i++) {
                if (element.equals(elements[i])) return i;
            }
        }
        return ELEMENT_NOT_FOUND;
    }

完善后的代码

package dongtaishuzu;




/**
 * @Author :Ersan
 * @Date 2020/10/27
 * @Description
 */
public class ArrayList<E> {
    private int size; //元素的数量
    private E[] elements;//所有的元素
    private static final int DEFAULT_CAPACITY=10;//数组默认大小为10
    private static final int ELEMENT_NOT_FOUND=-1;
    public ArrayList(int capaticy){
        capaticy=(capaticy<DEFAULT_CAPACITY)? DEFAULT_CAPACITY:capaticy;
        elements= (E[]) new Object[capaticy];
    }
    public ArrayList(){
        this(DEFAULT_CAPACITY); //不给值，capacity大小为默认值
    }
    /*
    *清除所有元素
    */
    public void clear(){
        for (int i = 0; i < size; i++) {
            elements[i]=null;//数组存的是对象的地址，这边把地址为null，相应的对象就会被java自带的垃圾回收器回收
        }
        size=0;//size=0，用户就会访问不到，但数组还在，避免重新创建数组更加消耗内存，如果数组多大，我们可以考虑缩容，这里缩容和扩容方法差不多
    }
    /*
    *元素的数量
    * return
    */
    public int size(){
        return size;
    }
    /*
     *是否为空
     * return
     */
    public boolean isEmpty(){
        return size==0;
    }
    /*
    *是否包含某个元素
    * param element
    * return
    */
    public  boolean contains(E element){
        return indexOf(element)!=ELEMENT_NOT_FOUND;
    }

    /*
    *添加元素到尾部
    * param element
    */
    public void add(E element){
        add(size,element);
    }

    /*
    *获取index位置的元素
    * param index
    * return
    */
    public E get(int index){
        rangeCheck(index);
        return elements[index];
    }

    /*
    *设置index位置的元素
    * param index
    * param element
    * return 原来的元素
    */
    public E set(int index,E element){
        rangeCheck(index);
        E old=elements[index];
        elements[index]=element;
        return old;
    }

    /*
    *在index位置插一个元素
    * param index
    * param element
    */
    public void add(int index,E element){
       // if (element==null) return;  是否支持null
        rangeCheckForAdd(index);
        ensureCapacity(size + 1);

        for (int i= size-1;  i >= index ; i--) {
            elements[i+1]=elements[i];
        }
        elements[index]=element;
        size++;
    }

    /*
    *删除index位置的元素
    *param index
    * return
    */
    public E remove(int index){
        rangeCheck(index);
        E old=elements[index];
        for (int i = index + 1; i < size; i++) {
            elements[i-1]=elements[i];
        }
        elements[--size]=null;
        return old;
    }

    @Override
    public String toString() {
        StringBuffer string=new StringBuffer();
        string.append("size=").append(size).append(",  [");
        for (int i = 0; i < size; i++) {
            if (i!=0){
                string.append(", ");
            }
            string.append(elements[i]);

//            if (i!=size-1){
//                string.append(",");
//            }
        }
        string.append("]");
        return string.toString();
    }

    /*
    *查看元素的索引
    * param element
    * return
    */
    public int indexOf(E element){
        if (element==null) {
            for (int i = 0; i < size; i++) {
                if (elements[i]==null) return i;
            }
        }else {

            for (int i = 0; i < size; i++) {
                if (element.equals(elements[i])) return i;
            }
        }
        return ELEMENT_NOT_FOUND;
    }

    private void outOfBounds(int index){
        throw new IndexOutOfBoundsException("Index:"+index+", Size:"+size);
    }
    private void rangeCheck(int index){
        if (index<0||index>=size) {
            outOfBounds(index);
        }
    }
    private void rangeCheckForAdd(int index){
        if (index<0||index>size) {
            outOfBounds(index);
        }
    }
    //保证要有capacity的容量
    private void ensureCapacity(int capacity){
        int oldCapacity=elements.length;
        if (oldCapacity>=capacity) return;

        //新容量为旧容量的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        Object[] newElements=new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newElements[i]=elements[i];
        }
        elements= (E[]) newElements;
    }
}