卜若的代码笔记-数据结构系列-第十一章：栈二.顺序栈(动态数组栈)

1.首先来说明一下什么叫做动态数组。

本质上还是数组，只是每次向数组里面添加的时候，如果检查到数组的长度不够的时候，就会产生以下动作：

a.new 一个两倍容量数组

b.将原始数组拷贝进去

关于拷贝方式的性能比较，我找到一篇比较好的博客

https://www.cnblogs.com/tabCtrlShift/p/9440566.html

可以去看一下。

 

c.释放掉原始数组(关于释放的问题，我会单独开辟一个专栏去介绍。在java里面我们默认自动释放)

 

分析后我们发现，我们目前需要的动态数组大概就一个函数

 

1.1 add(T t)

时间复杂度o(1+扩容时间)

我们看一下我们添加100w个数据耗费时间，同比100w数组的耗费时间同比ArrayList100w数据耗费时间

1.1.1 我们的

耗费时间：

1.1.2 java自带动态数组100w测试 

 

 

这边估计是我初始数组大小太小，被比下去了，我阔成256试试

 然后我们的自定义的动态数组就

 少了10ms！！！！！！！！！！！！！！！！！流弊！！！！！！！！！！！！！！！！！

 1.1.3 数组100w添加测试

1.2 get（int index）

时间复杂度o(1)

1.3 change(int index,T t)

时间复杂度o(1)

1.4 dilatation(int index)扩容

时间复杂度o(1)，根据java的数据拷贝机制。这边无法确定，但是时间复杂度通常是个常数。

1.4 len()

 

 

1.5 动态数组的原始代码：

package com.array.dynamic;

public interface IDynamicArray<T> {

    void add(T t);
    T get(int index);

    void dilatation(int index);
    void change(int index,T t);
    int len();
}

package com.array.dynamic;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Objects;

public class DynamicArray<T> implements IDynamicArray<T> {


    private T[] array;
    int index;
    public DynamicArray(int baseLen){

        array = (T[])new Object[baseLen];
    }
    @Override
    public void add(T t) {
        
        //扩容
        dilatation(index);

        array[index] = t;
        index++;

    }

    @Override
    public T get(int index) {
        return array[index];
    }
    
    
    @Override
    /**
     * 扩容
     */
    public void dilatation(int index) {
        if (index>=array.length){
            T[] cache = (T[])new Object[array.length*2];

            System.arraycopy(array,0,cache,0,array.length);

            array = cache;
        }
    }

    @Override
    public void change(int index, T t) {
        
        //需要扩容
        dilatation(index);
        array[index] = t;
    }

    @Override
    public int len() {
        return index;
    }
}

2.基于动态数组的顺序栈

实现：那就相当简单了

package com.stack.order;

import com.array.dynamic.DynamicArray;

public class OrderLinkStackByDArray<T> implements IStack<T>{


    public OrderLinkStackByDArray(int len){

        tArray = new DynamicArray<T>(len);

    }
    DynamicArray<T> tArray;
    int pointer = 0;


    @Override
    public void push(T t) {
        tArray.change(pointer,t);
        pointer++;
    }

    @Override
    public T pop() {
        return tArray.get(--pointer);
    }

    @Override
    public T peek() {
        return tArray.get(pointer-1);
    }

    @Override
    public T search(int index) {
        return tArray.get(index);
    }

    @Override
    public int len() {
        return pointer;
    }

}

使用：

 public static void main(String[] args) throws IOException {


        OrderLinkStackByDArray<Integer> intStack = new OrderLinkStackByDArray<>(20);

        for (int i =0;i<100;i++){
            intStack.push(i);
        }
        for (int j =0;j<100;j++){

            System.out.println( intStack.pop());

        }
    }

结果：

over！