一、棧

1.1 什麼是棧

棧是一種線性架構
相比數組，棧對應的操作是數組的子集
棧只能從一端添加元素，也只能從一端取出元素，最先放入堆棧中的內容最後被拿出來，最後放入堆棧中的內容最先被拿出來，被稱爲 先進後出 、後進先出。
這裏說的一端指的就是棧頂，刪除與添加均在棧頂進行操作

如下圖所示：

在上圖中我們可以看到棧是一種後進先出的數據結構，也就是 Last In First Out（LIFO） ，我們經常看到有 LIFO 找個單詞的時候，就是說這是一種後進先出的數據結構，在計算機的世界裏，棧擁有着不可思議的作用，接下來我們就來聊一聊，棧的應用。

1.2 棧的應用

1.2.1 無處不在的撤銷(undo)操作

棧在我們計算機的世界裏，都有哪些操作呢？不管我們是用開發工具，還是文本編輯，我們都會用一個很常用的操作 (undo操作) ，也就是我們常用的撤銷，當我們打字打快了，打錯了，我們只需要按住ctrl + z，就可以將我們輸入的文字撤銷掉，那麼棧是如何在撤銷中工作的，比如我們想打我愛我的祖國，這幾個字，但是我們打完 我愛我的，準備打祖國的時候，不小心打成了 一起，於是我們就可以進行 撤銷操作，將我們的 一起，進行出棧操作，然後在將 祖國添加到我們的棧裏面，這樣就完成了一次棧在撤銷中的工作。

如下圖所示：

1.2.1 計算機程序調用的系統棧

比如我有下面一段代碼：

public static void A(){
	System.out.println("A start");
	B();	
	System.out.println("A end");
}

public static void B(){
	System.out.println("B start");
	C();	
	System.out.println("B end");
}

public static void C(){
	System.out.println("C end");
}

首先我們會先進入方法 A()，打印輸出語句 A start，將方法 A()，作爲第一個棧，進行入棧操作，放入我們的系統棧中，然後進入方法 B()，打印輸出語句 B start，將方法 B()，作爲第二個棧進行入棧操作，再進入方法 C()，打印我們的 C end，到這裏入棧操作已經完成了，我們就會從我們的棧裏面去取我們剛纔入棧的方法，因爲 B() 方法是最後一個入棧的，遵循棧 先進後出 的原則，首先我們取出 B() 方法，進行 出棧操作，打印輸出語句 B end，最好我們取出A() 方法，進行 出棧操作，打印輸出語句 A end，以上整個就是我們程序調用系統棧的操作，我們來看下打印結果：

A start
B start
C end
B end
A end

執行流程如下圖所示：

如果能夠合理的運行棧，會對我們的程序起很好的作用，還有一些棧的應用，比如 遞歸算法

1.3 棧的實現

這裏我們關於數組部分，可以查看上一篇：動態數組

首先我們需要以下幾個棧元素：

int getSize(); // 獲取棧的元素多少
boolean isEmpty(); //查看棧是否爲空
void push(E e); //添加棧元素
E pop(); //出棧
E peek(); //查看棧頂元素是多少

具體方法實現：

自定義數組類：


public class Array<E> {

    private E[] data;
    private int size;

    // 構造函數，傳入數組的容量capacity構造Array
    public Array(int capacity){
        data = (E[])new Object[capacity];
        size = 0;
    }

    // 無參數的構造函數，默認數組的容量capacity=10
    public Array(){
        this(10);
    }

    // 獲取數組的容量
    public int getCapacity(){
        return data.length;
    }

    // 獲取數組中的元素個數
    public int getSize(){
        return size;
    }

    // 返回數組是否爲空
    public boolean isEmpty(){
        return size == 0;
    }

    // 在index索引的位置插入一個新元素e
    public void add(int index, E e){

        if(index < 0 || index > size)
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size.");

        if(size == data.length)
            resize(2 * data.length);

        for(int i = size - 1; i >= index ; i --)
            data[i + 1] = data[i];

        data[index] = e;

        size ++;
    }

    // 向所有元素後添加一個新元素
    public void addLast(E e){
        add(size, e);
    }

    // 在所有元素前添加一個新元素
    public void addFirst(E e){
        add(0, e);
    }

    // 獲取index索引位置的元素
    public E get(int index){
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("Get failed. Index is illegal.");
        return data[index];
    }

    public E getLast(){
        return get(size - 1);
    }

    public E getFirst(){
        return get(0);
    }

    // 修改index索引位置的元素爲e
    public void set(int index, E e){
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("Set failed. Index is illegal.");
        data[index] = e;
    }

    // 查找數組中是否有元素e
    public boolean contains(E e){
        for(int i = 0 ; i < size ; i ++){
            if(data[i].equals(e))
                return true;
        }
        return false;
    }

    // 查找數組中元素e所在的索引，如果不存在元素e，則返回-1
    public int find(E e){
        for(int i = 0 ; i < size ; i ++){
            if(data[i].equals(e))
                return i;
        }
        return -1;
    }

    // 從數組中刪除index位置的元素, 返回刪除的元素
    public E remove(int index){
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("Remove failed. Index is illegal.");

        E ret = data[index];
        for(int i = index + 1 ; i < size ; i ++)
            data[i - 1] = data[i];
        size --;
        data[size] = null; // loitering objects != memory leak

        if(size == data.length / 4 && data.length / 2 != 0)
            resize(data.length / 2);
        return ret;
    }

    // 從數組中刪除第一個元素, 返回刪除的元素
    public E removeFirst(){
        return remove(0);
    }

    // 從數組中刪除最後一個元素, 返回刪除的元素
    public E removeLast(){
        return remove(size - 1);
    }

    // 從數組中刪除元素e
    public void removeElement(E e){
        int index = find(e);
        if(index != -1)
            remove(index);
    }

    @Override
    public String toString(){

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

    // 將數組空間的容量變成newCapacity大小
    private void resize(int newCapacity){

        E[] newData = (E[])new Object[newCapacity];
        for(int i = 0 ; i < size ; i ++)
            newData[i] = data[i];
        data = newData;
    }
}

接口類：

public interface Stack<E> {
    int getSize();
    boolean isEmpty();
    void push(E e);
    E pop();
    E peek();
}

接口實現：

import com.lyy.datasty.Array;

/**
 * @program: Data-Structures
 * @ClassName ArrayStack
 * @description:
 * @author: lyy
 * @create: 2019-11-20 21:52
 * @Version 1.0
 * 用戶不能看棧中間的元素，只能看到棧頂的元素
 **/
public class ArrayStack<E> implements Stack<E>{

    Array<E> array;

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

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

    @Override
    public int getSize() {
        return 0;
    }

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

    public int getCapacity(){
        return array.getCapacity();
    }

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

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

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

    @Override
    public String toString() {
            StringBuilder res = new StringBuilder();
            res.append("Stack：");
            res.append('[');
        for (int i = 0; i < array.getSize(); i++) {
            res.append(array.get(i));
            if(i != array.getSize() - 1)
                res.append("，");
        }
        res.append("] top");//哪裏是棧頂
        return res.toString();
    }
}

測試結果：

Stack: [0] top
Stack: [0, 1] top
Stack: [0, 1, 2] top
Stack: [0, 1, 2, 3] top
Stack: [0, 1, 2, 3, 4] top
Stack: [0, 1, 2, 3] top

從結果中我們可以看到，我們每循環一次就添加一條數據，這裏爲了好讓我們知道哪一個是棧頂，我們在最後一個添加的數據那裏，加了一個 top ，最新增加的數據，就是我們的棧頂，當我們添加完成後，可以看到棧數據爲：[0, 1, 2, 3, 4] top，當我們出棧一個數據後，我們就可以看到 棧頂數據 4 就沒有了，以上就是對於棧實現的代碼，感興趣的小夥伴可以自己實現一遍，源碼在最後我會放在 github上，有興趣的小夥伴記得下載。

1.4 棧的時間複雜度

ArrayStack：

方法	時間複雜度
void push(E e)	O(1) 均攤
E pop()	O(1) 均攤
E peek()	O(1)
int getSize()	O(1)
boolean isEmpty()	O(1)

二、隊列

2.1 隊列認識

隊列與棧一樣是一種線性結構，因此以常見的線性表如數組、鏈表作爲底層的數據結構。
相比數組，隊列對應的操作是數組的子集
隊列只能從一端（隊尾）添加元素，只能從一端（隊首）取出元素，也就是隊尾添加元素，在隊頭刪除元素
隊列是一種先進先出的數據結構（先到先得）
隊列列中的數據元素遵循“先進先出”（First In First Out）的原則，簡稱 FIFO 結構。
隊列是一個 先進先出的線性表，相應的也有 順序存儲和鏈式存儲兩種方式。

在隊列中，新添加的一端爲隊尾，另一端爲隊首，當一個元素從隊尾進入隊列時，一直向隊首移動，直到它成爲移除的元素爲止。這種 先進先出（FIFO） 模式，在我們生活中也隨處可見，比如：我們去銀行櫃檯取錢，我們在取錢之前就要先去取號，先做 入隊操作，也就是我們隊列中的在 隊尾添加元素，新來的人等待排隊，等待前面的人處理完，當前面取號的人在櫃檯處理完之後，就會叫下一個號碼，這個過程就是 出隊操作，只有當在我們前面的人，都處理完之後纔會輪到我們。

如下圖：

2.2 數組隊列的實現（順序存儲）

首先我們需要以下幾個棧元素：

int getSize(); // 獲取隊列的元素多少
boolean isEmpty(); //查看隊列是否爲空
void enqueue(E e); //添加隊列元素
E dequeue(); //刪除隊列隊首元素
E getFront(); //獲取隊首隊列元素

2.2.1 接口實現

public interface Queue<E> {
    int getSize();
    boolean isEmpty();
    void enqueue(E e);
    E dequeue();
    E getFront();
}

2.2.2 接口類實現

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

    private Array<E> array;

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

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

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

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

    public int getCapacity(){
        return array.getCapacity();
    }

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

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

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

    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append("Queue: ");
        res.append("front [");
        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);
            if(i % 3 == 2){
                queue.dequeue();
                System.out.println(queue+"：================="+(i % 3));
            }
        }
    }
}

2.2.3 執行結果

Queue: front [0] tail
Queue: front [0, 1] tail
Queue: front [0, 1, 2] tail
Queue: front [1, 2] tail：=================2
Queue: front [1, 2, 3] tail
Queue: front [1, 2, 3, 4] tail
Queue: front [1, 2, 3, 4, 5] tail
Queue: front [2, 3, 4, 5] tail：=================2
Queue: front [2, 3, 4, 5, 6] tail
Queue: front [2, 3, 4, 5, 6, 7] tail
Queue: front [2, 3, 4, 5, 6, 7, 8] tail
Queue: front [3, 4, 5, 6, 7, 8] tail：=================2
Queue: front [3, 4, 5, 6, 7, 8, 9] tail

首先我們總共是循環十次，添加到隊列中，每天添加一次打印隊列中的元素，如果遇到 i % 3 == 2，我們就去除隊首的元素，就是我們在結果中看到的 =================2的位置，每次都會把最先添加（隊首）的元素給刪除掉，從上面的結果中可以看出，當我們每次去 queue.dequeue()元素的時候，其實就是操作數組中的 size --，這樣對於我們隊列來說效率其實是很慢的，如果刪除隊首元素，後面的元素就要往前移動，對應的時間複雜度就是O(n)。

2.2.4 數組隊列複雜度分析

方法	時間複雜度
void enqueue(E e)	O(1) 均攤
E dequeue()	O(n)
E getFront()	O(1)
int getSize()	O(1)
boolean isEmpty()	O(1)

2.2.4 數組隊列的問題

從上面的執行結果我們可以看到，對於隊列的執行來說，刪除隊首元素，後面的元素就要往前移動，如果，有一個ｎ個元素的隊列，數組下標 0 的一端是隊首，入隊操作（void enqueue(E e)）就是通過數組下標一個個順序追加，不需要移動元素，但是如果刪除（E dequeue()）隊首元素，後面的元素就要往前移動，我們可以想象一下，有一個 10000 的元素，我們從下標 0 開始添加，添加完成後，刪除隊首的元素，那麼我們需要移動 9999 次，這個操作的複雜度，對於 數組隊列來說是非常耗時的一個操作。

如下圖所示：

2.3 隊列的實現（循環隊列）

2.3.1 循環隊列

每當我們刪除隊首元素，後面的元素就要往前移動，因爲，我們可以使用另一種方式來實現隊列，也就是我們上面提到的 鏈式存儲，也稱 循環隊列，這種方式是使用鏈表實現，比如：有兩個指針，front 指向隊頭，tail 指向對尾元素的下一個位置，元素出隊時 front 往後移動，如果到了對尾則轉到頭部，同理入隊時 tail 後移，如果到了對尾則轉到頭部，這樣通過下標 front 出隊時，就不需要移動元素了,如果當我們的 front == tail的時候，則說明隊列爲空。如下圖所示：

這樣我們的刪除操作就變成了一個O(1) 的操作，如果當我們的 tail 滿了，但是 front 前面還有空間，我們可以將 tail 引入之前在 front 前面刪除的下標中，這樣我們又可以繼續添加數據了，這就是循環隊列的來由，我們可以把我們的數組隊列看成一個 “環”，7 之後的索引是 0 ，什麼時候我們的隊列纔會滿呢？當我們的 tail + 1 = front的時候，就說明我們的隊列纔算真正的滿了，如下圖所示：

那麼，這個時候 front == tail爲空既可以標識爲空也可以用於堆滿，因此我們可以用 (tail + 1) % c == front的表示隊列滿了，在這裏 c = 8就是我們隊列的長度，例如我們的 front 指的是 2 而我們的 tail 指的是 1 的話，那麼這個隊列就是滿的，因爲（1+1）% 8 = 2，大家可以想象一下，我們的鐘表，我們的鐘表十一點鐘下一個時間，我們可以叫12點也可以叫0點，之後又變成了一點兩點三點以此類推，我們整個循環隊列的就想鐘錶一樣形成了一個環。

注意：在這裏我們需要在 capacity 中浪費一個空間，用來判斷隊列是否滿了，因此我們需要在用戶傳遞隊列大小的時候，進行 +1 操作，再添加一個元素空間。

2.3.1 循環隊列編碼實現

首先我們需要以下幾個元素：

int getSize(); // 獲取隊列的元素多少
boolean isEmpty(); //查看隊列是否爲空
void enqueue(E e); //添加隊列元素
E dequeue(); //刪除隊列隊首元素
E getFront(); //獲取隊首隊列元素

1、接口類：

public interface Queue<E> {

    int getSize();
    boolean isEmpty();
    void enqueue(E e);
    E dequeue();
    E getFront();
}

2、接口實現類：

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

    private E[] data;//存放的元素
    private int front, tail;//兩個指針
    private int size;//元素個數

    public LoopQueue(int capacity){
        data = (E[])new Object[capacity + 1];//進行 +1 操作，用來判斷隊列是否滿了
        front = 0;
        tail = 0;
        size = 0;
    }

    public LoopQueue(){
        this(10);
    }

    public int getCapacity(){
        return data.length - 1;//獲取數據長度，需要在原來的基礎上 -1
    }

    @Override
    public boolean isEmpty(){
        return front == tail;//判斷隊列是否滿了，只需要判斷是否 front == tail
    }

    @Override
    public int getSize(){
        return size;
    }

    @Override
    public void enqueue(E e){//添加元素

        if((tail + 1) % data.length == front)//如果判斷 (tail + 1) % c == front 成立，表示隊列滿了，自動擴容
            resize(getCapacity() * 2);//擴容原來的兩倍

        data[tail] = e;
        tail = (tail + 1) % data.length;
        size ++;
    }

    @Override
    public E dequeue(){//刪除元素

        if(isEmpty())//判斷是否爲空
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");

        E ret = data[front];//獲取隊首元素
        data[front] = null;//設置爲null
        front = (front + 1) % data.length;//設置新隊首的下標位置
        size --;//大小 -1
        if(size == getCapacity() / 4 && getCapacity() / 2 != 0)//如果長度大小爲 getCapacity() / 4 並且 getCapacity() / 2 != 0 的時候，自動縮減
            resize(getCapacity() / 2);
        return ret;
    }

    @Override
    public E getFront(){//獲取隊首元素
        if(isEmpty())
            throw new IllegalArgumentException("Queue is empty.");
        return data[front];
    }

    private void resize(int newCapacity){//擴容操作

        E[] newData = (E[])new Object[newCapacity + 1];
        for(int i = 0 ; i < size ; i ++)
            newData[i] = data[(i + front) % data.length];

        data = newData;
        front = 0;
        tail = size;
    }

    @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 = 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();
    }

    public static void main(String[] args){

        LoopQueue<Integer> queue = new LoopQueue<>(5);
        for(int i = 0 ; i < 10 ; i ++){
            queue.enqueue(i);
            System.out.println(queue);

            if(i % 2 == 0){
                queue.dequeue();
                System.out.println(queue+"：================"+i % 2);
            }
        }
    }
}

3、執行結果：

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

Queue：大小個數
capacity：是隊列長度，可以看到自動擴容和縮減
front：隊首 tail：隊尾

2.3.2 循環隊列時間複雜度

方法	時間複雜度
void enqueue(E e)	O(1) 均攤
E dequeue()	O(1) 均攤
E getFront()	O(1)
int getSize()	O(1)
boolean isEmpty()	O(1)

2.3 順序存儲和循環隊列性能對比

測試代碼：

public class Main {

    // 測試使用q運行opCount個enqueueu和dequeue操作所需要的時間，單位：秒
    private static double testQueue(Queue<Integer> q, int opCount){

        long startTime = System.nanoTime();

        Random random = new Random();
        for(int i = 0 ; i < opCount ; i ++)
            q.enqueue(random.nextInt(Integer.MAX_VALUE));
        for(int i = 0 ; i < opCount ; i ++)
            q.dequeue();

        long endTime = System.nanoTime();

        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {

        int opCount = 100000;

        ArrayQueue<Integer> arrayQueue = new ArrayQueue<>();
        double time1 = testQueue(arrayQueue, opCount);
        System.out.println("ArrayQueue, time: " + time1 + " s");

        LoopQueue<Integer> loopQueue = new LoopQueue<>();
        double time2 = testQueue(loopQueue, opCount);
        System.out.println("LoopQueue, time: " + time2 + " s");
    }
}

執行結果：

ArrayQueue, time: 3.552273371 s
LoopQueue, time: 0.011760769 s

我們可以看到 LoopQueue 性能是遠遠高於 ArrayQueue 的，我們如果把數據加大，差異會更加明顯，如果是 1000000 的話，我的新電腦是 ArrayQueue：234s，而LoopQueue 依舊是 0.幾秒，大家可以自行測試感受下，不過就算是新電腦，在 1000000 數據下，也要等待一會才能執行完成。

到這裏棧和隊列就講完了，大家文章中有改進的地方或者有什麼不懂的地方，歡迎大家在下面留言，下一篇，我們將講解數據結構中最重要一個知識點——鏈表，喜歡的可以關注我，我是牧小農，我喂自己帶鹽，學習路上你我同行，大家加油！

數據結構線性結構篇——棧和隊列

文章目錄

一、棧

1.1 什麼是棧

1.2 棧的應用

1.2.1 無處不在的撤銷(undo)操作

1.2.1 計算機程序調用的系統棧

1.3 棧的實現

1.4 棧的時間複雜度

二、隊列

2.1 隊列認識

2.2 數組隊列的實現（順序存儲）

2.2.1 接口實現

2.2.2 接口類實現

2.2.3 執行結果

2.2.4 數組隊列複雜度分析

2.2.4 數組隊列的問題

2.3 隊列的實現（循環隊列）

2.3.1 循環隊列

2.3.1 循環隊列編碼實現

2.3.2 循環隊列時間複雜度

2.3 順序存儲和循環隊列性能對比

Spring Cloud 部署時如何使用 Kubernetes 作爲註冊中心和配置中心

深入淺出ReentrantLock(可重入鎖)

【併發編程】安全發佈對象—單例模式升級版

IDEA類和方法註釋模板設置（超詳細教程）

HTTP協議精準詳細介紹

數據結構線性結構篇——棧和隊列

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

數據結構 線性結構篇——棧和隊列

文章目錄

一、棧

1.1 什麼是棧

1.2 棧的應用

1.2.1 無處不在的撤銷(undo)操作

1.2.1 計算機程序調用的系統棧

1.3 棧的實現

1.4 棧的時間複雜度

二、隊列

2.1 隊列認識

2.2 數組隊列的實現（順序存儲）

2.2.1 接口實現

2.2.2 接口類實現

2.2.3 執行結果

2.2.4 數組隊列複雜度分析

2.2.4 數組隊列的問題

2.3 隊列的實現（循環隊列）

2.3.1 循環隊列

2.3.1 循環隊列編碼實現

2.3.2 循環隊列時間複雜度

2.3 順序存儲和循環隊列性能對比

數據結構線性結構篇——棧和隊列