演算法之美：棧和佇列

玉剛說發表於2019-03-03
演算法佇列

本文由玉剛說寫作平臺提供寫作贊助

原作者：像一隻狗

版權宣告：本文版權歸微信公眾號玉剛說所有，未經許可，不得以任何形式轉載

演算法，一門既不容易入門，也不容易精通的學問。

對於筆者來說演算法算是我程式設計師生涯很不擅長的技能之一了，自從網際網路界招人進入平靜期後，越來越多的大廠在社招的時候不但會考驗面試者的工作所用到的技能，而且會用演算法題來考驗面試者的邏輯思維能力和基本資料結構的掌握能力。這也就讓想要社招進入大廠的部分同學有了一些望而卻步的心理，畢竟工作中大部分時間在與UI層面的邏輯打交道，資料處理方面及時之前在學校中掌握的還不做，幾年的CV生活，估計也忘的差不多了。

但是作為一條有夢想的鹹魚，我們還是要重拾這些知識的。今天筆者將會挑選幾道棧與佇列的題目來回顧下相關演算法的基本知識。

棧與佇列分別是兩種資料結構，不同語言對於棧和佇列有著不同的宣告，在 java 中 Stack 類是繼承自 Vector 集合的子類，Queue 則是以介面形式存在，常用的其實現類是 LinkedList 這個雙向佇列。在C++的標準模版庫也是有這兩個資料結構定義的具體類的。

棧資料結構的特點是 FILO（first in last out） 即先進後出，佇列則是 FIFO（first in first out）即先進先出。相信棧與佇列的資料結構的基本特點大家也是熟記於胸了。下面就帶大家看一道面試題來帶大家看下這兩者在面試題中的形式。

由兩個棧實現一個佇列 （✭✭✩✩✩）

題目難度兩顆星，主要考察了對於棧和佇列的資料結構特點。

前文介紹了，對於一個棧來說遵循 pop 操作時從棧的頂部取一個元素，對於佇列來說 poll 操作時從佇列隊首取一個元素。所以該題翻譯過來就是使用兩個棧定義一種先放入的元素，最先被取出的資料結構。

此題應考慮到兩種情況，首先最簡單的一種情況，假設有 1，2，3，4，5 個元素依次進入自定義的佇列，再依次取出。由於是進棧操作都進行完了才進行出棧操作，所以我們只需在元素出隊時，將進棧元素倒入另一個空棧中即可。示意圖如下：

演算法之美：棧和佇列

再一種情況是，如果 add poll 操作是交替進行的，那麼如何保證資料結構先進先出的定義呢？比如先放入 1，2，3然後要進行一次取出操作取出 1，隨後在進行 add 操作放入4，5，這種情況下如何操作兩個棧，才能保證之後再取出的時候元素為 2，3，4，5 順序？實際上我們只需要保證一下兩點就可以：

  1. 無論如果 StackA（最開始add元素的那個棧） 要往 StackB 中壓入元素，那麼必須選擇一次性全部壓入。
  2. 無論什麼時候從佇列中取元素，必須保證元素是從 StackB 中 pop 出的，也就是說，當 StackB 不為空的時候絕不能再次向 StackB 中壓入元素。

為了方便理解可以看下邊這幅圖：

演算法之美：棧和佇列

明白了需要注意的點後就是該寫程式碼的時候了，需要注意的點在圖中已經用紅色字型標出了，也就是在存入元素一直往 StackA 中存，取元素是從 StackB 中取，但要要注意的是取的時候需要保證 StackB 為空的時候要先將 StackA 中元素一次性壓如 StackB 中，在進行從 StackB 中取的操作。

    public static class  TwoStackQueue<E>{
        private Stack<E> stackA;
        private Stack<E> stackB;

        public TwoStackQueue() {
            stackA = new Stack<>();
            stackB = new Stack<>();
        }

        /**
         * 新增元素邏輯
         * @param e 要新增的元素
         * @return 這裡只是遵循 Queue 的習慣，這裡簡單處理返回 true 即可
         */
        public boolean add(E e){
            stackA.push(e);
            return true;
        }

        /**
         * 去除元素的時候需要判斷兩個地方，StackA & StackB 是否都為空
         * StackB 為空的時候講StackA中的元素全部依次壓入 StackB
         * @return 返回佇列中的元素 如果佇列為空返回 null
         */
        public E poll(){
            //如果佇列中沒有元素則直接返回空，也可以選擇丟擲異常
            if (stackB.isEmpty() && stackA.isEmpty()){
                return null;
            }
            
            if (stackB.isEmpty()){
                while (!stackA.isEmpty()){
                    stackB.add(stackA.pop());
                }
            }
            
            return stackB.pop();
        }

        /**
         * peek 操作不取出元素，只返回佇列頭部的元素值 
         * @return 佇列頭部的元素值
         */
        public E peek(){
            //如果佇列中沒有元素則直接返回空，也可以選擇丟擲異常
            if (stackB.isEmpty() && stackA.isEmpty()){
                return null;
            }

            if (stackB.isEmpty()){
                while (!stackA.isEmpty()){
                    stackB.add(stackA.pop());
                }
            }

            return stackB.peek();
        }
    }
複製程式碼

對應的 C++ 解法：

#include <stdio.h>
#include <stack>
using namespace std;

template <typename T> class TStackQueue
{
public:
    void add(T t);
    T poll();
    
private:
    stack<T> stackA;
    stack<T> stackB;
};

template <typename T> void TStackQueue<T>::add(T node) {
    stackA.push(node);
}
template<typename T> T TStackQueue<T>::poll(){
    if (stackB.empty() && stackA.empty()) {
        return NULL;
    }
    
    if (stackB.empty()) {
        while (!stackA.empty()) {
            stackB.push(stackA.top());
            stackA.pop();
        }
    }
    T node = stackB.top();
    stackB.pop();
    return node;
}
複製程式碼

兩個佇列實現一個棧 （✭✭✩✩✩）

上道題我們完成了兩個棧實現一個佇列的題目，那麼兩個佇列實現一個棧又該注意哪些呢？

首先佇列是先進先出，我們可以發現佇列無論怎麼倒，我們不能逆序一個佇列。既然不能套用上題的解法，那麼就得另謀出路，但是可以預知無非就是兩個佇列進行交替的入隊出隊操作，那麼唯一要做的就是判斷目前出隊的值是否是按照放入元素順序中最後放入的元素。 依舊畫圖舉例

演算法之美：棧和佇列

這裡我們只看首次取出操作，那麼需要注意一點， 如何判斷哪一次取出操作後 QueueA 為空？

事實上作為 Queue 作為容器，我們可以通過事先定義好的方法 queue.size() 去判斷一個佇列中元素的個數，有人可能說這是犯規，其實不是的。題目中給出是讓你用佇列去實現，那麼佇列中公共 API 都是你可以用的。所以可以想象出下面的虛擬碼：

//如果 queueA 的大小不為 0 則迴圈取出元素
while(queueA.size() > 0){
    //被取出的元素
    int result = queueA.poll();
    // 這裡注意我們取出元素後再去判斷一次，佇列是否為空，如果為空代表是最後一個元素
    if(queueA.size() != 0){
        queueB.add(result)
    }else{
        return result;
    }
}
複製程式碼

上文我們只是說了一次取出操作，那麼一次取出操作後，再次放入元素應該怎麼放，我們似乎又遇到了困難。

與上題不同的是，我們應該先思考如果連續兩次取出應該怎麼操作，上面一次取出後 QueueA 空了，所以我們如果按照相同的思路將 B 中的元素倒入 A 中，那麼將會得到 3 ，這看起來沒什麼問題。那麼如果下一步進行的 push 操作，那麼應該放入 QueueA 還是 QueueB 中才能保證元素先進後出的規則呢，很容易想到是放入 B 中。 那麼總結一下操作要點：

  1. 任何時候兩個佇列總有一個是空的。
  2. 新增元素總是向非空佇列中 add 元素。
  3. 取出元素的時候總是將元素除隊尾最後一個元素外，匯入另一空佇列中，最後一個元素出隊。

接上圖我們開看第一次取出操作後可能的兩種操作情況：

演算法之美：棧和佇列

思路縷清楚了，那麼時候寫程式碼了：

public static class TwoQueueStack<E> {
   private Queue<E> queueA;
   private Queue<E> queueB;

   public TwoQueueStack() {
       queueA = new LinkedList<>();
       queueB = new LinkedList<>();
   }

   /**
    * 選一個非空的佇列入隊
    *
    * @param e
    * @return
    */
   public E push(E e) {
       if (queueA.size() != 0) {
           System.out.println("從 queueA 入隊 " + e);
           queueA.add(e);
       } else if (queueB.size() != 0) {
           System.out.println("從 queueB 入隊 " + e);
           queueB.add(e);
       } else {
           System.out.println("從 queueA 入隊 " + e);
           queueA.add(e);
       }
       return e;
   }

   public E pop() {
       if (queueA.size() == 0 && queueB.size() == 0) {
           return null;
       }

       E result = null;
       if (queueA.size() != 0) {
           while (queueA.size() > 0) {
               result = queueA.poll();
               if (queueA.size() != 0) {
                   System.out.println("從 queueA 出隊 並 queueB 入隊 " + result);
                   queueB.add(result);
               }
           }
           System.out.println("從 queueA 出隊 " + result);

       } else {
           while (queueB.size() > 0) {
               result = queueB.poll();
               if (queueB.size() != 0) {
                   System.out.println("從 queueB 出隊 並 queueA 入隊 " + result);
                   queueA.add(result);
               }
           }
           System.out.println("從 queueB 出隊" + result);
       }
       return result;
   }
}
複製程式碼

為了方便大家理解我將文章進行下測試：

 public static void main(String[] args) {
        TwoQueueStack<Integer> queueStack = new TwoQueueStack<>();
        queueStack.push(1);
        queueStack.push(2);
        queueStack.push(3);
        queueStack.push(4);
        queueStack.pop();
        queueStack.pop();
        queueStack.push(5);
        queueStack.pop();
    }
複製程式碼

結果為下面所示,看上去我們的程式碼是對的

從 queueA 入隊 1
從 queueA 入隊 2
從 queueA 入隊 3
從 queueA 入隊 4
從 queueA 出隊 並 queueB 入隊 1
從 queueA 出隊 並 queueB 入隊 2
從 queueA 出隊 並 queueB 入隊 3
從 queueA 出隊 4
從 queueB 出隊 並 queueA 入隊 1
從 queueB 出隊 並 queueA 入隊 2
從 queueB 出隊3
從 queueA 入隊 5
從 queueA 出隊 並 queueB 入隊 1
從 queueA 出隊 並 queueB 入隊 2
從 queueA 出隊 5
複製程式碼

附C++ 程式碼實現：

#include <stdio.h>
#include<queue>
#include<exception>

using namespace std;

template <typename T> class TQueueStack
{
public:
    void push(const T& node);
    T pop();
    
private:
    queue<T> queueA;
    queue<T> queueB;
};

// 插入元素
template<typename T> void TQueueStack<T>::push(const T& node)
{
    
    //插入到非空佇列，如果均為空則插入到queueB中
    if (queueA.size() == 0)
    {
        queueB.push(node);
    }
    else
    {
        queueA.push(node);
    }
}

template<typename T> T TQueueStack<T>::pop()
{
    if (queueA.size() == 0 && queueB.size() == 0)
    {
        return NULL;
    }
    T head;
    if (queueA.size() > 0)
    {
        while (queueA.size()>1)
        {
            //queueA中的元素依次刪除，並插入到queueB中，其中queueA刪除最後一個元素
            //相當於從棧中彈出隊尾元素
            T& data = queueA.front();
            queueA.pop();
            queueB.push(data);
        }
        head = queueA.front();
        queueA.pop();
    }
    else
    {
        while (queueB.size()>1)
        {
            //queueB 中的元素依次刪除，並插入到 queueA 中，其中 queueB 刪除最後一個元素
            //相當於從棧中彈出隊尾元素
            
            T& data = queueB.front();
            queueB.pop();
            queueA.push(data);
        }
        head = queueB.front();
        queueB.pop();
    }
    return head;
}
複製程式碼

判斷出棧順序是否符合要求（✭✭✭✩✩）

經歷了上兩道題，大家是不是感覺對棧和佇列更反感，哦不對是更瞭解了呢。（額~ 一不小心把實話說出來了）。下面我們來看第二道題這是一個有關於出棧順序的判斷的題目:

題目: 輸入兩個整數陣列，第一個表示一個棧的壓入序列，請寫一個函式，判斷第二個陣列是否為該棧的出棧序列，假設陣列中的所有數字均不相等。例如序列 1,2,3,4,5 是某棧的壓入順序，序列 4,5,3,2,1 是該壓棧序列對應的一個彈出序列，但 4,3,5,1,2 就不可能是該壓棧序列的彈出序列。

看到這道題我們首先應該去理解題目中的怎麼去判斷是否符合出棧順序，其實題目想要表達的意思是如果以陣列 A 的方式進棧但並不是一次全部進棧，比如我們先進棧1，2，3，4 然後出棧 4，然後進棧 5，然後在出棧 5，3，2，1。 那麼什麼情況下是不可能滿足的出棧順序呢？比如 1，肯定是比 2 先進棧的，所以 2肯定比 1先出棧。所以解題的關鍵就在於，如何判斷陣列2 中的元素，是按陣列1 中某種進棧順序操作的出棧序列。

思路是如果我們在進棧的同時維護一個出棧角標，如果棧頂元素等於 popA[popIndex] 的時候，將角標加一，並出棧該元素，並繼續判斷下一個棧頂元素，如果棧頂元素不等於 popA[popIndex] 的時候繼續入棧元素，直到所有元素入棧完畢如果，棧不為空則表示 popA 不是一個出棧序列。通過下圖可以更好的理解題目要考察的內容：

演算法之美：棧和佇列

所以在程式設計的只需要注意一下三點：

  1. 執行放入操作後，如果棧頂的元素等於對應角標在 popA 陣列中的元素值，那麼就需要出棧該元素，同事角標加1
  2. 如果棧頂的元素不等於對應角標在 popA 陣列中的元素值，那麼就執行放入操作。
  3. 待所有的元素都被放入棧中，此時如果棧為空，那麼 popA 就是一個出棧序列，反之則不是。

下面看程式碼實現：

public static class Solution {

   public boolean IsPopOrder(int[] pushA, int[] popA) {
       int len = pushA.length;

       Stack<Integer> stack = new Stack<>();
       for (int pushIndex = 0, popIndex = 0; pushIndex < len; pushIndex++) {
           stack.push(pushA[pushIndex]);
           //如果棧頂元素等於 popA[popIndex] 則一直出棧且 popIndex++
           while (popIndex < popA.length && popA[popIndex] == stack.peek()) {
               stack.pop();
               popIndex++;
           }
       }
       return stack.isEmpty();
   }
}
複製程式碼

C++實現如下

class Solution {
public:
    bool IsPopOrder(vector<int> pushA, vector<int> popA) {
        if(pushA() == 0) return false;
        vector<int> stack;
        for(int i = 0,j = 0 ;i < pushA.size();){
            stack.push_back(pushA[i++]);
            while(j < popA.size() && stack.back() == popA[j]){
                stack.pop_back();
                j++;
            }       
        }
        return stack.empty();
    }
};
複製程式碼

測試結果如下：

public static void main(String[] args) {

   Solution solution = new Solution();
   int[] pushA = new int[]{1, 2, 3, 4, 5};
   int[] popA1 = new int[]{4, 3, 5, 1, 2};
   int[] popA2 = new int[]{4, 5, 3, 2, 1};

   System.out.println("popA1 是否是出棧佇列 " + solution.IsPopOrder(pushA, popA1));
   System.out.println("popA2 是否是出棧佇列 " + solution.IsPopOrder(pushA, popA2));
}
// 結果
//popA1 是否是出棧佇列 false
//popA2 是否是出棧佇列 true
複製程式碼

總結

本文列舉了棧和佇列的一些面試題目，通過這些面試題目我們可以瞭解到一些面試中演算法的考點，對於運算相關題目，我們還是需要多加練習，但是不要害怕自己某些地方不會限制瞭解題思路，通過多加練習，記住見過的解題中的規律，相信經過一段時間練習後，也會感受到自我的提高。

最後歡迎大家關注我的掘金專欄，不定時分享一些自己的學習工作總結。

像一隻狗的掘金專欄

參考：
《劍指 offer 第二版》
《程式設計師程式碼面試指南 – 左程雲》

演算法之美：棧和佇列
歡迎關注我的微信公眾號，接收第一手技術乾貨

相關文章