栈与队列

记录《剑指offer》中所有关于栈和队列的题目，以及LeetCode中的相似题目。

相关题目列表

题目

栈与队列一般是作为解决算法题的辅助数据结构出现，在很多实际题目中有广泛的应用，所以需要多加练习理解。

面试题7： 用两个栈实现队列

题目： 用两个栈实现一个队列。队列的声明如下，请实现它的两个函数appendTail和deleteHead，分别完成在队列尾部插入节点和在队列头部删除节点的功能。

template <typename T> class CQueue
{
public:
    CQueue(void);
    ~CQueue(void);
    
    void appendTail(const T& node);
    T deleteHead();
    
private:
    stack<T> stack1;
    stack<T> stack2;
};

题目分析

本题为使用先进后出的两个栈实现一个先进先出的队列。
我们令stack1作为插入栈，每次采用appendTail操作时，都向stack1中压入元素。接下来考虑如何构造deleteHead。我们以stack2作为弹出栈，若想实现弹出优先插入的元素，我们需要将stack1中的元素逐个弹出并压入到stack2中，这样stack2中的首元素即为其实优先压入元素。
因此，我们得到一个删除元素的步骤：当stack2中不为空时，在stack2中的栈顶元素是最先进入队列的元素，可以弹出。如果stack2为空时，我们把stack1中的元素逐个弹出并压入stack2。由于先进入队列的元素被压入stack1的低端，经过弹出和压入之后就处于stack2的顶端了，又可以直接弹出。

其压入弹出过程如下图所示：

压入弹出示意图

参考代码

#include<iostream>
#include<stack>

using namespace std;

class Solution
{
public:
    void push(int node)
    {
        stackIn.push(node);
    }

    int pop()
    {
        if (stackOut.empty())
        {
            while (!stackIn.empty())
            {
                stackOut.push(stackIn.top());
                stackIn.pop();
            }
        }

        int head = stackOut.top();
        stackOut.pop();

        return head;
    }

    bool empty()
    {
        return stackIn.empty() && stackOut.empty();
    }

private:
    stack<int> stackIn;
    stack<int> stackOut;
};

int main()
{
    Solution solu;
    solu.push(1);
    solu.push(2);
    solu.push(3);
    solu.push(4);
    solu.push(5);

    while (!solu.empty())
    {
        cout << solu.pop() << " ";
    }
}

相似题目

本题与LeetCode中的232. Implement Queue using Stacks
完全一致，另外LeetCode中还有一道使用两个队列实现一个栈的题目225. Implement Stack using Queues
。
这两题的参考代码见：
LeetCode 232 code
LeetCode 225 code
还可以在牛客网 剑指offer上完成对本题的练习。

面试题21： 包含min函数的栈

题目： 定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的min函数。在该栈中，调用min、push、及pop的时间复杂度都是O(1)。

题目分析

此题借助一个辅助栈用于存储min元素，即可实现。原始栈压入，则辅助栈压入最小元素；原始栈弹出，则辅助栈直接弹出。

参考代码

class Solution {
public:
    std::stack<int> stack_data, min_data;
    void push(int value) {
        stack_data.push(value);
        if (min_data.empty())
            min_data.push(value);

        if (value < min_data.top()){
            min_data.push(value);
        }
        else {
            min_data.push(min_data.top());
        }
    }
    void pop() {
        stack_data.pop();
        min_data.pop();
    }
    int top() {
        return stack_data.top();
    }
    int min() {
        return min_data.top();
    }
};

相似题目

本题与LeetCode中的155. Min Stack完全一致，参考代码见：
LeetCode 155 code
还可以在牛客网 剑指offer中完成对本题的练习。

面试题22： 栈的压入、弹出序列

题目： 输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出序列。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入序列，序列4,5,3,2,1是该栈对应的一个弹出序列，但4,3,5,1,2就不可能是该栈的弹出序列。

题目分析

解决这个问题很直观的方法就是建立一个辅助栈，把输入的第一个序列中的数字依次压入该辅助栈，并按照第二个序列的顺序依次从该栈中弹出数字。通过模拟压入弹出过程，判断序列的可行性。
示例过程如下图所示：

示例1

示例2

参考代码

#include<iostream>
#include<vector>
#include<stack>
using namespace std;

class Solution {
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        bool result = false;
        int pushV_size = pushV.size();
        int popV_size = popV.size();
        if (!pushV.empty() && pushV_size == popV_size){
            int pPush = 0, pPop = 0;
            std::stack<int> stackData;
            while (pPop < popV_size){
                while (stackData.empty() || stackData.top() != popV[pPop]){ //在pushV中寻找popV中的数,需要判断栈的起始状态为空的情况
                    if (pPush == pushV_size)    //都没有找到
                        break;
                    stackData.push(pushV[pPush]);   //将找到之前的数压入临时栈
                    pPush++;
                }

                if (stackData.top() != popV[pPop])
                    break;

                stackData.pop();    //找到之后弹出
                pPop++;
            }

            if (stackData.empty() && pPop == popV_size)     //最终判断条件，如果临时栈中为空，并且popV中所有元素都经过了比较
                result = true;
        }
        return result;
    }
};

int main()
{
    vector<int> push = {1,2,3,4,5};
    vector<int> pop = {4,3,5,2,1};

    Solution solu;
    bool result = solu.IsPopOrder(push, pop);

    cout << result << endl;

    return 0;
}

相似题目

可以在牛客网 剑指offer上完成对本题的练习。

面试题65： 滑动窗口的最大值

题目： 给定一个数组和滑动窗口的大小，请找出所有滑动窗口里最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，它们的最大值分别为{4,4,6,6,6,5}。

题目分析

本题可以采用暴力方法，扫描每个滑动窗口的所有数字找出最大值，如果滑动窗口的大小为k，需要O(k)时间才能找出滑动窗口里的最大值。对于长度为n的输入数组，这个算法的总时间复杂度为O(nk)。

实际上一个滑动窗口可以看成是一个队列。当窗口滑动时，处于窗口的第一个数字被删除，同时在窗口的末尾添加一个新的数字。这符合队列的先进先出特性。如果能从队列中找出它的最大数，这个问题也就解决了。

我们不把滑动窗口的每个数值都存入队列中，而是只把有可能成为滑动窗口的最大值的数字存入到一个两端开口的队列中（deque）。

示例如下图：

参考代码

#include<iostream>
#include<vector>
#include<deque>

using namespace std;

class Solution
{
public:
    vector<int> maxInWindows(const vector<int>& num, unsigned int size)
    {
        vector<int> res;
        deque<int> index;   //双向队列保存索引

        if (num.size() == 0 || size == 0)
            return res;

        for (int i = 0; i < num.size(); ++i)
        {
            while (index.size() && num[i] > num[index.back()])  //如果新来的值大于deque末尾值，则弹出末尾值
                index.pop_back();
            if (index.size() && (i-index.front()) >= size)  //如果front已经不在窗口中，则弹出front
                index.pop_front();
            index.push_back(i);

            if (i+1 >= size)    //当到达滑动窗口长度时，开始记录最大值
                res.push_back(num[index.front()]);
        }
        return res;
    }
};

int main()
{
    vector<int> num = {2,3,4,2,6,2,5,1};
    Solution solu;
    vector<int> res = solu.maxInWindows(num, 3);

    for (int i = 0; i < res.size(); ++i)
    {
        cout << res[i] << ",";
    }

    return 0;
}

相似题目

本题与LeetCode中的239. Sliding Window Maximum完全一致，参考代码见：
LeetCode 239 code

还可以在牛客网 剑指offer上完成对本题的练习。

【参考】
[1] 《剑指offer》

欢迎转载，转载请注明出处：wenmingxing 《剑指offer》栈与队列专题