算法打卡 Day10（栈与队列）-用栈实现队列 + 用队列实现栈

今天开始进入栈与队列啦！

首先我们来学习一下栈与队列的基础知识~

栈与队列理论基础

栈与队列的区别是：栈是先进后出，队列是先进先出

栈和队列是 STL（C++ 标准库）中的两个数据结构。

三个最为普遍的 STL 版本：

• HP STL：其他版本的 C++ STL，一般是以 HP STL 为蓝本实现出来的，HP STL 是 C++ STL 的第一个实现版本，而且开放源代码。
• P.J.Plauger STL：由 P.J.Plauger 参照 HP STL 实现出来的，被 Visual C++ 编译器所采用，不是开源的。
• SGI STL：由 Silicon Graphics Computer Systems 公司参照 HP STL 实现，被 Linux 的 C++ 编译器 GCC 所采用，SGI STL 是开源软件，源码可读性甚高。

栈

栈提供 push 和 pop 等接口，所有元素符合先进后出的规则，栈不提供走访功能，也不提供迭代器（iterator），栈不像 set 或者 map 提供迭代器 iterator 来遍历所有的元素。

栈是以底层容器完成其所有的工作，对外提供统一的接口，底层容器是可插拔的（可以控制使用哪种容器实现栈的功能），因此，STL 中栈不被归类为容器，而被归类为 container adaptor（容器适配器）。

由图中栈的结构可知，栈的底层实现可以是 vector，deque 和 list

在常用的 STL 结构 SGI STL 中，如果没有指定底层实现时默认以 deque 为缺省情况下栈的底层结构。

deque 是一个双向队列，只要封住一端，只开通另一端就可以实现

SGI STL 中队列的底层实现在缺省情况下同样是用 deque 实现的。

指定 vector 为栈的底层实现，初始化栈的语句如下：

std::stack<int, std::vector<int>> third; //使用vector为底层容器的栈

以 list 为底层实现，初始化 queue 的语句如下：

std::queue<int, std::list<int>> third;//使用以list为底层容器的队列

同样地，STL 队列也不能被归为容器，而是 container adapter（容器适配器）。

Leetcode 232-用栈实现队列

题目描述

https://leetcode.cn/problems/implement-queue-using-stacks/description/

解题思路

使用栈模拟队列时，我们可以使用 in 和 out 两个栈来模拟，输入栈 push 进队列中的数据，但这个时候没有办法按照队列先进先出的顺序，因此需要一个输出栈，其与输入栈的开口方向相反，以实现 pop 时数据的先进先出

代码实现如下

class MyQueue {
public:
    stack<int>stIn;
    stack<int>stOut;
    MyQueue() {

    }

    void push(int x) {
        stIn.push(x);
    }

    int pop() {
        //首先要判断stOut是否为空
        if (stOut.empty()) {
            while (!stIn.empty())
            {
                stOut.push(stIn.top());
                stIn.pop();
            }
        }
        int result = stOut.top();
        stOut.pop();
        return result;
    }

    int peek() {
        int res = this->pop();//直接使用前面已经写好的pop函数，实现函数的复用
        stOut.push(res);//将刚刚pop函数弹出的元素添加
        return res;
    }

    bool empty() {
        return stIn.empty() && stOut.empty();
    }
};

Leetcode 225-用队列实现栈

题目描述

https://leetcode.cn/problems/implement-stack-using-queues/description/

解题思路

使用两个队列模拟栈的过程是，将栈的元素 push 进入主要队列，然后当 pop 时，采用辅助队列将除最后一个元素之外的元素纳入，之后再将主要队列中的剩余的最后一个元素 pop 出来，实现栈的 pop 功能。整体代码如下：

class MyStack {
public:
    queue<int>queue1;
    queue<int>queue2;
    MyStack() {

    }

    void push(int x) {
        queue1.push(x);
    }

    int pop() {
        int size = queue1.size()-1;
        while (size--) {
            int element = queue1.front();
            queue1.pop();
            queue2.push(element);
        }
        int result = queue1.front();
        queue1.pop();
        queue1 = queue2;
        while (!queue2.empty()) {
            queue2.pop();
        }
        return result;
    }

    int top() {
        return queue1.back();
    }

    bool empty() {
        return queue1.empty();
    }
};

进一步，我们可以优化解题思路，仅采用一个队列来模拟栈，其思路是将队列内除最后一个元素外的其他元素弹出并重新 push 入队列，这样就实现了队列的第一个元素即栈会弹出的第一个元素：

class MyStack {
public:
    queue<int> que;
    MyStack() {

    }

    void push(int x) {
        que.push(x);
    }

    int pop() {
        int size = que.size() - 1;
        while (size--) {
            que.push(que.front());
            que.pop();
        }
        int result = que.front();
        que.pop();
        return result;
    }

    int top() {
        return que.back();
    }

    bool empty() {
        return que.empty();
    }
};