卜若的代碼筆記-數據結構系列-第十一章：棧二.順序棧(動態數組棧)

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！