棧和佇列的應用非常多，但其起實現嘛，其實很少人關心。

雖然蘋果一直宣傳什麼最小年齡的程式設計者，它試圖把程式設計大眾化，弱智化，但真正的複雜問題，需要抽絲剝繭的時候，還是要 PRO 人士出場，所以知根知底，實在是必要之舉(而非無奈之舉)。

大門敞開，越往裡走越窄，競爭會越激烈。

棧

基本特性

就一條，FILO。但是用在其他複雜資料結構，比如樹，或者用在其他應用場景的時候，比如記錄呼叫過程中的變數及其狀態等，超有用。

應用舉例

比如 撤銷操作:

使用者每次的錄入都會入棧，被系統記錄，然後寫入檔案；但是使用者撤銷，則是當前的操作出棧，此時上一次操作位於棧頂，也就相當於本次操作被取消了。

這裡始終 操作棧頂 即可。

比如 程式呼叫棧:

函式一呼叫就會入棧(因為這個函式可能內部還要呼叫別的函式)，函式呼叫返回時，出棧。

每次返回時不知道下一步執行誰？不會的，它會參考棧裡面記錄的呼叫鏈。

比如 括號匹配 問題:

遇到左括號(只要是左邊括號)就入棧，碰到右邊括號就比較，如果匹配，那麼就出棧。(不匹配直接返回false)

(抱歉，Python程式碼寫多了，老是忘記加上 ; 分號)

順序棧實現

定義好介面，然後內部封裝一個動態陣列，實現介面的方法即可。

大概的介面，通用的方法就五個:

public interface Stack<E> {
    //介面中宣告相關方法即可
    boolean isEmpty();
    int getSize();

    E pop();
    E peek();
    void push(E e);
}
 

然後實現程式碼如下:

// 真正的實現
import array.AdvanceDynamicArray;

public class ArrayStack<E> implements Stack<E> {
    //底層實現是動態陣列，所以內部直接引用動態陣列就好了
    AdvanceDynamicArray<E> array;

    public ArrayStack(int capacity) {
        array = new AdvanceDynamicArray<>(capacity);
    }

    public ArrayStack() {
        array = new AdvanceDynamicArray<>();
    }


    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }

    @Override
    public int getSize() {
        return array.getSize();
    }

    @Override
    public E pop() {
        return array.pop();
    }

    @Override
    public E peek() {
        return array.getLast();
    }

    @Override
    public void push(E e) {
        array.append(e);
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("Stack [");
        for (int i = 0; i < array.getSize(); i++) {
            res.append(array.get(i));
            if (i != array.getSize() - 1) {
                res.append(", ");
            }
        }
        res.append("]，top right");
        return res.toString();
    }
}
 

沒事兒簡單測試一下看看:

//測試一下棧
private static void test_stack_1() {
  ArrayStack<Integer> stack = new ArrayStack<>(); //預設內部動態陣列容量 10
  //推入 5 個元素
  for(int i=0; i< 5; i++){
    stack.push(i);
    System.out.println(stack); //每次入棧，列印一次
  }
  System.out.println("---------");
  stack.pop();
  System.out.println(stack);
}

// 列印輸入結果如下:
Stack [0]，top right
Stack [0, 1]，top right
Stack [0, 1, 2]，top right
Stack [0, 1, 2, 3]，top right
Stack [0, 1, 2, 3, 4]，top right
---------
Stack [0, 1, 2, 3]，top right

複雜度分析

基本都在末尾操作，所以基本都是 O(1)。

(push 和 pop 由於涉及到擴容和縮容，所以上面的 O(1) 其實是均攤的)

普通佇列

同樣是一個操作受限的容器

基本特性

感覺就一條 FILO 。

應用舉例

我接觸的用到的佇列，要麼是支援併發操作的併發佇列，由於加鎖，所以併發性並不是很好。

另外一種就是非同步任務佇列，即把工作加入佇列，由外部 IO 介面讀取(可能是多個執行緒，也可能是多路複用的讀)

哦，個人在廣度優先遍歷時用過。(需要統計相關目錄及其子目錄的各種各樣語言的程式碼量，此時把子目錄加入到佇列尾部，然後不斷出隊檢查當前目錄的檔案)

順序佇列實現

• 定義好介面，底層實現用 動態陣列 完成介面中的方法
• 入隊 enqueue，出隊 dequeue 為核心 (不必擔心滿和空，因為一個在陣列尾部操作，一個在陣列頭部操作，空間夠不夠底層陣列負責)

介面及其實現 如下:

//介面
public interface Queue<E> {
    boolean isEmpty();
    int getSize();

    E dequeue();
    E getFront();

    void enqueue(E e);
}

public class ArrayQueue<E> implements Queue<E> {

    private AdvanceDynamicArray<E> array;

    public ArrayQueue(int capacity) {
        array = new AdvanceDynamicArray<>(capacity);
    }

    public ArrayQueue() {
        array = new AdvanceDynamicArray<>();
    }

    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }

    @Override
    public int getSize() {
        return array.getSize();
    }

    @Override
    public E dequeue() {
        return array.popLeft();
    }

    @Override
    public E getFront() {
        return array.getFirst();
    }

    @Override
    public void enqueue(E e) {
        array.append(e);
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("Queue: [");
        for(int i = 0; i< array.getSize(); i++) {
            res.append(array.get(i));
            if(i != array.getSize() - 1) {
                res.append(", ");
            }
        }
        res.append("]，tail");
        return res.toString();
    }


    //測試看看
    public static void main(String[] args) {
        ArrayQueue<Integer> queue = new ArrayQueue<>();
        //放入元素
        for(int i = 0; i< 10; i++) {
            queue.enqueue(i);
            System.out.println(queue); //放入一個元素，檢視一次佇列
        }

        //出棧試試
        System.out.println("--------");
        queue.dequeue();
        System.out.println(queue);
    }
}

輸出結果:

Queue: [0]，tail
Queue: [0, 1]，tail
Queue: [0, 1, 2]，tail
Queue: [0, 1, 2, 3]，tail
Queue: [0, 1, 2, 3, 4]，tail
Queue: [0, 1, 2, 3, 4, 5]，tail
Queue: [0, 1, 2, 3, 4, 5, 6]，tail
Queue: [0, 1, 2, 3, 4, 5, 6, 7]，tail
Queue: [0, 1, 2, 3, 4, 5, 6, 7, 8]，tail
Queue: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]，tail
--------
Queue: [1, 2, 3, 4, 5, 6, 7, 8, 9]，tail

複雜度分析

其實就是出隊的時候，從頭部出，涉及到移動(覆蓋元素)，所以為 O(n)

其他操作都只在尾部進行，所以都是 O(1)，其中尾部 enqueue 是均攤。總體來說，這個出隊的消耗時間太大了。如果要 底層實現不變，可以實現其他佇列，減少移動次數。

迴圈佇列

迴圈佇列是如何減少移動操作？

出隊一定要移動元素麼？ 如果只移動記錄隊首的標記，這樣會不好好一點？

• 嘗試移動標記隊首、隊尾的標誌(索引)

迴圈佇列有一個非常重要的點，區分佇列滿、佇列空的條件:

• 佇列滿 (tail+1)%capacity == front
• 佇列空 tail == front

人為的浪費一個空間，不存元素，和佇列空條件區分開。(否則佇列滿和空都能用 tail == front 來判斷，無法區分)

基本原理

其實也就是相對於普通佇列而言，支援其優化的理由在哪裡。

首先老規矩，front 肯定指向的是第一個元素，tail 肯定執行的是最後一個元素的後一個位置，大致如下圖:

也即是說，還是基於順序儲存的結構，新增兩個變數記錄隊首和隊尾的索引。

然後看一下 tail 和 front 都是怎麼變？ 一句話總結:

• 新增元素 tail++ ((tail+1)%capacity)
• 刪除元素 front++ ((front+1)%capacity)

在佇列中移動索引，front 或者 tail， 都要取模，以免越界。

細說，初始狀態，沒有元素，兩者都指向索引為 0 的位置，然後新增元素 tail++，不斷新增不斷++；當且僅在隊首出元素的時候，front++。

此時出隊就不需要移動元素覆蓋前面的了，直接移動索引 front 即可。然後就出現這樣的狀況:

發現前面有可用的空間，然後也還會出現這樣的狀態:

然後再往裡面扔一個元素試試，結果就迴圈了:

那再放一個呢？佇列滿了。

(因為前面說過認為的空出一個空間，讓佇列滿和佇列空區分開來)

這裡的擴容怎麼設計？需要修改底層動態陣列麼？

原始的動態陣列方式，即使它擴容，也無法改變 front 和 tail 關係，所以不適用。
(且擴容拷貝的時候，也要考慮偏移，即取模問題)

具體實現

先把基於 Queue 介面把框架寫出來，然後填補 enqueue 和 dequeue 方法。

public class LoopQueue<E> implements Queue<E> {
    //內部自己維護一個數組
    private E[] data;
    private int front, tail; //front 指向頭，tail 指向隊尾的下一個元素
    private int size; //其實可以用通過 front, tail 實現，但複雜，容易出錯


    public LoopQueue(int capacity){
        data = (E[]) new Object[capacity+1]; //因為要故意浪費一個空間
        front = tail = 0;
        size = 0;
    }

    public LoopQueue(){
        data = (E[]) new Object[10+1]; //因為要故意浪費一個空間，預設儲存10個元素
        front = tail = 0;
        size = 0;
    }

    //外部能感知的實際能儲存的 capacity
    public int getCapacity() {
        return data.length -1; //注意是 data.length 少一個
    }

    //快捷方法，判斷佇列滿 -- 使用者不用關心，client始終可以放入 (因為會動態擴容)
    private boolean isFull() {
        //return (tail+1)%getCapacity() == front;
        return (tail+1)%data.length == front; //判斷佇列滿，用實際的 data.length 判斷
    }

    @Override
    public boolean isEmpty() {
        //return size == 0;
        return front == tail; //特別注意佇列為空的條件
    }

    @Override
    public int getSize() {     
        return size; //專門有一個變數維護
    }
    
    @Override
    public E getFront() {
        //但凡要取元素，都要看看是否為空
        if(isEmpty()){
            throw new IllegalArgumentException("佇列為空，不能出隊");
        }
        return data[front];
    }
  
    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(String.format("Queue: size=%d, capacity=%d\n", size, getCapacity()));

        res.append("front [");
        /*
        for (int i = 0; i < size; i++) {
            res.append(data[i]);
            if (i != size - 1) {
                res.append(", ");
            }
        } */
       //相對於 front 偏移的方式也是可以的 data[(i+front)%data.length]
        for (int i = front; i != tail; i = (i+1)%data.length) {
            res.append(data[i]); 
            if ((i+1)%data.length != tail) { //不是最後一個元素之前的一個元素
                res.append(", ");
            }
        }        
        res.append("] tail");
        return res.toString();
    }  

  // ---------------------- TODO
    @Override
    public E dequeue() {
        //TODO
        return null;
    }

    @Override
    public void enqueue(E e) {
        //TODO

    }
}

上面的遍歷方式也可以用取模偏移來寫。

然後實現遺留下來的兩個 TODO:

入隊，先看佇列是否為滿。

• 如果滿，則重新分配空間，此時新空間自然應該從 0 開始放元素:

    @Override
    public void enqueue(E e) {
        //新增之前，先要看看佇列是否是滿的
        if (isFull()) {
            //丟擲異常 or 動態擴容(包括移動元素)
            resize(2 * getCapacity()); //當前實際佔用空間*2
        }

        //入佇列
        //data[tail++] = e; // tail++ 可能超過了 data.length
        data[tail] = e;
        tail = (tail + 1) % data.length;
        size++;
    }

    private void resize(int newCapacity) {
        //改變容量，然後移動元素，重置索引
        E[] newData = (E[]) new Object[newCapacity + 1];

        //複製: 把舊的元素，放入新的陣列
        //新陣列的索引是從 0 -> size 的
        for (int i = 0; i < size; i++) {
            //newData[i] = data[?];
            newData[i] = data[(front + i) % data.length]; //索引移動，用的是data.length 判斷
        }

        //重置索引
        front = 0;
        tail = size; //實際個數是不變的
        data = newData; //data.length 變化了，所以 getCapacity() 自然也變了
    }

出隊 操作，先看佇列是否為空:

• 如果為空，不返回或者丟擲異常

    @Override
    public E dequeue() {
        //先看看是否為空
        if(isEmpty()){
            throw new IllegalArgumentException("佇列為空，不能出隊");
        }

        E ret = data[front];
        //最好還是把 data[front]  處理一下
        data[front] = null;
        front = (front+1)%data.length;
        size--;
        // 是否需要縮減容量

        return ret;
    }

其實還沒有完，如果一直出列，size 比 data.length 小太多，則有必要縮減容量。

即在出隊 dequeue 的程式碼中有必要新增 是否需要縮減容量 這一段:

    @Override
    public E dequeue() {
        //先看看是否為空
        if(isEmpty()){
            throw new IllegalArgumentException("佇列為空，不能出隊");
        }

        E ret = data[front];
        //最好還是把 data[front]  處理一下
        data[front] = null;
        front = (front+1)%data.length;
        size--;

        //縮減容量(lazy 縮減)，當實際儲存為 1/4 capacity時，capacity縮減為一半
        if(size == getCapacity()/4 && getCapacity()/2 != 0) {
            resize(getCapacity()/2); //縮減後的容量不能為0
        }

        return ret;
    }

測試看看:

    public static void main(String[] args) {
        LoopQueue<Integer> queue = new LoopQueue<>(); //預設實際儲存 10 個元素
        //儲存  11 個元素看看
        for(int i=0; i<11; i++){
            queue.enqueue(i);
            System.out.println(queue); // 在 10 個元素滿的時候回擴容
        }
        //出隊試試
        System.out.println("------");
        queue.dequeue();
        System.out.println(queue);
        //出隊到只剩 5 個元素，即 20/4 時，縮減容量
        queue.dequeue();
        queue.dequeue();
        queue.dequeue();
        queue.dequeue();
        queue.dequeue();
        // 6, 7, 8, 9 10
        System.out.println(queue); //此時容量變為 10 了
    }

執行結果:

Queue: size=1, capacity=10
front [0] tail
Queue: size=2, capacity=10
front [0, 1] tail
Queue: size=3, capacity=10
front [0, 1, 2] tail
Queue: size=4, capacity=10
front [0, 1, 2, 3] tail
Queue: size=5, capacity=10
front [0, 1, 2, 3, 4] tail
Queue: size=6, capacity=10
front [0, 1, 2, 3, 4, 5] tail
Queue: size=7, capacity=10
front [0, 1, 2, 3, 4, 5, 6] tail
Queue: size=8, capacity=10
front [0, 1, 2, 3, 4, 5, 6, 7] tail
Queue: size=9, capacity=10
front [0, 1, 2, 3, 4, 5, 6, 7, 8] tail
Queue: size=10, capacity=10
front [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] tail
Queue: size=11, capacity=20
front [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] tail
------
Queue: size=10, capacity=20
front [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] tail
Queue: size=5, capacity=10
front [6, 7, 8, 9, 10] tail

實現總結

• 開闢內部陣列時，data.length 始終要比指定的 capacity 多一個
  • 即便是 resize，也是 new Object[newCapacity + 1]
• 佇列空 front == tail，佇列滿 (tail+1)%capacity == tail
• 滿、空的判斷都要放在前面(enqueue, dequeue)
• 索引的移動都要取模，包括 tail 和 front

此時，出隊的複雜度也變為 O(1) 了(因為根本沒有移動元素)。

複雜度分析

還分析啥？因為普通佇列 dequeue 時要移動元素，O(n)，所以這裡才會拉扯一個迴圈佇列。

所以除了 dequeue 是均攤的 O(1) 以及 enqueue 均攤O(1)，其他操作都是 O(1)。

(鏈式儲存的部分，後續再補充進來)

如果有不正確的地方，歡迎批評指正。

以防萬一，我這裡還是把相關程式碼上傳到 gayhub 上了