数据结构与算法之数组讲解

最新推荐文章于 2022-09-08 15:02:50 发布

dream21st

最新推荐文章于 2022-09-08 15:02:50 发布

阅读量194

点赞数

分类专栏：数据结构与算法文章标签：数据结构与算法

本文链接：https://blog.csdn.net/qq_36305027/article/details/100620053

版权

数据结构与算法专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1，数组实现说明

定义一个数组容量（capacity）为8，初始化4个数据1,2,3,4

int[] datas=new int[8];
for(int i=1;i<=4;i++){
    datas[i-1]=i;
}

此时，数据中的size为4，索引指向的第一个空闲位置索引为4，如果此时在改数组末尾增加一个元素5

datas[size]=5

size++

在指定索引index处插入元素

public void add(int index,int e){
    if(index<0 || index>this.size){
        throw new IllegalArgumentException("index must between 0 and size");
    }
    for(int position=size-1;position>=index;position--){
        this.datas[position+1]=this.datas[position];
    }
    this.datas[index]=e;
    this.size++;
}

在指定索引index处删除元素

public int remove(int index){
    if(index<0 || index>=this.size){
        throw new IllegalArgumentException("index must between 0 and size");
    }
    int ret=this.datas[index];
    for(int i=index+1;i<size;i++){
        this.datas[i-1]=this.datas[i];
    }
    size--;
    return ret;
}

下面给出具体的带泛型实现

2，代码实现

package com.dream21th.algorithmicdatastructure.array;


/**
 * @Auther: hp
 * @Date: 2019/9/7 15:42
 * @Description:
 */
public class MyExtendArray<E> {

    private E[] datas;

    private int size;

    /**
     * 创建有参构造函数，初始化数组容量
     * @param capacity
     */
    public MyExtendArray(int capacity){
        datas=(E[])new Object[capacity];
        size=0;
    }

    /**
     * 构造无参函数，初始化数组容量
     */
    public MyExtendArray(){
        this(10);
    }

    public int getSize(){
        return this.size;
    }

    public boolean isEmpty(){
        return this.size==0;
    }

    /**
     * 在指定索引位置加值
     * @param index
     * @param e
     */
    public void add(int index,E e){
        if(index<0 || index>this.size){
            throw new IllegalArgumentException("index must between 0 and size");
        }
        if(this.size==datas.length){
            resize(2*datas.length);
        }
        for(int position=size-1;position>=index;position--){
            this.datas[position+1]=this.datas[position];
        }
        this.datas[index]=e;
        this.size++;
    }

    private void resize(int newCapacity) {

        E[] newDatas= (E[]) new Object[newCapacity];

        for(int i=0;i<this.datas.length;i++){
            newDatas[i]=this.datas[i];
        }
        this.datas=newDatas;
    }

    /**
     * 在第一个位置加入元素
     * @param e
     */
    public void addFirst(E e){
        this.add(0,e);
    }

    /**
     * 在最后一个位置添加元素
     * @param e
     */
    public void addLast(E e){
        this.add(size,e);
    }

    public E get(int index){
        if(index<0 || index>=this.size){
            throw new IllegalArgumentException("index must between 0 and size");
        }
        return this.datas[index];
    }

    public void set(int index,E e){
        if(index<0 || index>=this.size){
            throw new IllegalArgumentException("index must between 0 and size");
        }
        this.datas[index]=e;
    }

    public boolean contain(E e){
        for(int i=0;i<size;i++){
            if(this.datas[i].equals(e)){
                return true;
            }
        }
        return false;
    }

    public int find(int e){
        for(int i=0;i<size;i++){
            if(this.datas[i].equals(e)){
                return i;
            }
        }
        return -1;
    }

    public E remove(int index){
        if(index<0 || index>=this.size){
            throw new IllegalArgumentException("index must between 0 and size");
        }
        E ret=this.datas[index];
        for(int i=index+1;i<size;i++){
            this.datas[i-1]=this.datas[i];
        }
        size--;
        this.datas[size]=null;
        if(this.size==this.datas.length/2){
            resize(this.datas.length/2);
        }
        return ret;
    }

    public E removeFirst(){
        return remove(0);
    }

    public E removeLast(){
        return remove(size-1);
    }
    
    @Override
    public String toString() {

        StringBuilder builder=new StringBuilder();
        builder.append(String.format("Array: size = %d,capacity = %d \n",this.size,this.datas.length));
        builder.append("[");
        for(int i=0;i<size;i++){
            builder.append(this.datas[i]);
            if(i!=size-1){
                builder.append(",");
            }
        }
        builder.append("]");
        return builder.toString();
    }
}

3，resize为数组动态扩缩容方式，目的是减少空间浪费，具体设计细节是当增加数据数据容量达到上限时，扩增容量到原来的2倍，当删除数据时，如果当前数组size为容量一般，自动缩到原来的二分之一（为避免复杂度震荡，此处可以采用到原容量四份之一，缩容到二分之一）

4，复杂度分析

addLast O（1）

addFirst O（n）增加整体复杂度为O(n),

add O（n/2）

removeLast O（1）

removeFirst O（n）删除整体复杂度为O(n),

remove O（n/2）

在知道索引的前提下，update和find的空间复杂度为O(1)

采用均摊算法计算增加和删除复杂度

如上图，在进行8次末尾增加数据后，在进行第九次增加数据时，会触发动态扩容，此过程的空间复杂度为