• 从C语言到C++_18(stack和queue的常用函数+相关练习)力扣

    目录

    1. stack

    1.1 栈的概念

    1.2 stack 的介绍和使用

    2. queue

    2.1 队列的概念

    2.2 queue 的介绍和使用

    3. 栈和队列的相关选择题

    答案：

    4. 栈和队列的相关OJ题

    155. 最小栈 - 力扣（LeetCode）

    解析代码：

    剑指 Offer 31. 栈的压入、弹出序列 - 力扣（LeetCode）

    946. 验证栈序列 - 力扣（LeetCode）

    解析代码：

    150. 逆波兰表达式求值 - 力扣（LeetCode）

    解析代码：

    225. 用队列实现栈 - 力扣（LeetCode）

    解析代码：法一（两个队列）

    解析代码：法二（一个队列）

    232. 用栈实现队列 - 力扣（LeetCode）

    解析代码：

    本章完。

    1. stack

    1.1 栈的概念

    数据结构与算法⑧(第三章_上)栈的概念和实现(力扣：20. 有效的括号)_GR C的博客-CSDN博客

    ① 栈是一种特殊的线性表，它只允许在固定的一端进行插入和删除元素的操作。

    ② 进行数据插入的删除和操作的一端，称为栈顶 。另一端则称为 栈底 。

    ③ 栈中的元素遵守后进先出的原则，即 LIFO原则（Last In First Out）。

    压栈：栈的插入操作叫做 进栈 / 压栈 / 入栈 ，入数据在栈顶。

    出栈：栈的删除操作叫做出栈。出数据也在栈顶。

    1.2 stack 的介绍和使用

    https://cplusplus.com/reference/stack/stack/?kw=stack

     stack 是一种容器适配器，（下一篇会讲解）专门用在具有后进先出操作的上下文环境中，

    其删除只能从容器的一端进行 元素的插入与提取操作。
    stack 是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，

    并提供一组特定 的成员函数来访问其元素，将特定类作为其底层的，

    元素特定容器的尾部(即栈顶)被压入和弹出。
    标准容器 vector、deque、list 均符合这些需求，默认情况下，

    如果没有为 stack 指定特定的底层容器， 则使用 deque。
    stack 的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，

    这些容器类应该支持以下操作：

    empty：判空操作
    back：获取尾部元素操作
    push_back：尾部插入元素操作
    pop_back：尾部删除元素操作

    看看接口函数：

     通过观察文档我们发现，接口相较于之前的 string、vector 和 list 少了很多。

    它甚至连拷贝构造和析构都没有自己实现，然而这些都得益于容器适配器的使用。

    不难发现， stack、queue 也没有迭代器，这也不难理解，

    毕竟能让你随便遍历，不就破坏了栈和队列的原则了。

    常用函数：

     简单使用：

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. void test_stack() 
    6. {
    7.     stack<int> st;
    8.     st.push(1);
    9.     st.push(2);
    10.     st.push(3);
    11.     st.push(4); 
    12.     st.push(5);
    13.  
    14.     cout <<  "st.size() = " << st.size() << endl;
    15.     while (!st.empty()) 
    16.     {
    17.         cout << st.top() << " "; // 后进先出
    18.         st.pop();
    19.     }
    20.     cout << endl;
    21. }
    22.  
    23. int main()
    24. {
    25.     test_stack();
    26.     return 0;
    27. }

    2. queue

    2.1 队列的概念

    数据结构与算法⑨(第三章_下)队列的概念和实现(力扣：225+232+622)_GR C的博客-CSDN博客

    ① 队列只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表。

    ② 入队列，进行插入操作的一端称为 队尾。出队列，进行删除操作的一端称为 队头。

    ③ 队列中的元素遵循先进先出的原则，即 FIFO 原则（First In First Out）

    2.2 queue 的介绍和使用

    https://cplusplus.com/reference/queue/queue/

     队列是一种容器适配器，（下一章会讲解）专门用于在FIFO上下文(先进先出)中操作，

    其中从容器一端插入元素，另一端 提取元素。
    队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，

    queue 提供一组特定的 成员函数来访问其元素。元素从队尾入队列，从队头出队列。
    标准容器类 deque 和 list 满足了这些要求。默认情况下，

    如果没有为 queue 实例化指定容器类，则使用标准容器 deque。
    底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。

    该底层容器应至少支持以下操作：
    empty：检测队列是否为空
    size：返回队列中有效元素的个数
    front：返回队头元素的引用
    back：返回队尾元素的引用
    push_back：在队列尾部入队列
    pop_front：在队列头部出队列

    常用函数：

     简单使用：

    1. #include 
    2. #include 
    3. #include 
    4. using namespace std;
    5.  
    6. void test_stack() 
    7. {
    8.     stack<int> st;
    9.     st.push(1);
    10.     st.push(2);
    11.     st.push(3);
    12.     st.push(4); 
    13.     st.push(5);
    14.  
    15.     cout <<  "st.size() = " << st.size() << endl;
    16.     while (!st.empty()) 
    17.     {
    18.         cout << st.top() << " "; // 后进先出
    19.         st.pop();
    20.     }
    21.     cout << endl;
    22. }
    23.  
    24. void test_queue()
    25. {
    26.     queue<int> q;
    27.     q.push(1);
    28.     q.push(2);
    29.     q.push(3);
    30.     q.push(4);
    31.     q.push(5);
    32.  
    33.     cout << "q.size() = " << q.size() << endl;
    34.     while (!q.empty())
    35.     {
    36.         cout << q.front() << " "; // 先进先出
    37.         q.pop();
    38.     }
    39.     cout << endl;
    40. }
    41.  
    42. int main()
    43. {
    44.     test_stack();
    45.     test_queue();
    46.  
    47.     return 0;
    48. }

    3. 栈和队列的相关选择题

    1. 下列代码的运行结果是（ ）

    1. void main()
    2. {
    3. 	stack<char> S;
    4. 	char x, y;
    5. 	x = 'n';y = 'g';
    6. 	S.push(x);S.push('i');S.push(y);
    7. 	S.pop();S.push('r');S.push('t');S.push(x);
    8. 	S.pop();S.push('s');
    9. 	while (!S.empty())
    10. 	{
    11. 		x = S.top();
    12. 		S.pop();
    13. 		cout << x;
    14. 	};
    15. 	cout << y;
    16. }

    A.gstrin

    B.string

    C.srting

    D.stirng

    2. 下列代码的运行结果是（ ）

    1. void main()
    2. {
    3. 	queue<char> Q;
    4. 	char x, y;
    5. 	x = 'n';y = 'g';
    6. 	Q.push(x);Q.push('i');Q.push(y);
    7. 	Q.pop();Q.push('r');Q.push('t');Q.push(x);
    8. 	Q.pop();Q.push('s');
    9. 	while (!Q.empty())
    10. 	{
    11. 		x = Q.front();
    12. 		Q.pop();
    13. 		cout << x;
    14. 	};
    15. 	cout << y;
    16. }

    A.gstrin

    B.grtnsg

    C.srting

    D.stirng

    3. 一个栈的输入顺序是a,b,c,d,e则下列序列中不可能是出栈顺序是( )

    A.e,d,a,c,b

    B.a,e,d,c,b

    C.b,c,d,a,e

    D.b,c,a,d,e

    4. 以下是一个tree的遍历算法，queue是FIFO队列，请参考下面的tree，正确的输出是( )

            1

      2         3

    4 5        6 7

    queue.push(tree.root )

    while(true)

    node = queue.pop()

    output(node.value)//输出节点对应数字

    if(null==node)

    break

    for(child_node in node.children)

    queue.push(child_node)

    A.1376254

    B.1245367

    C.1234567

    D.1327654

    答案：

    1. B

    分析:S.push(x);S.push('i');S.push(y); 入栈了字母“nig”  左边栈底 右边栈顶

      S.pop();S.push('r');S.push('t');S.push(x); 字母g出栈，然后入栈字母“rtn”，此时栈数据      为"nirtn"

      S.pop();S.push('s');字母n出栈，s入栈，最终的栈数据为nirts

       while(!S.empty()){} 栈不空出栈打印，按相反顺讯出栈，所以打印结果为：strin

      cout<

    2. B

    分析：Q.push(x);Q.push('i');Q.push(y); 入队数据为:nig 左边对头，右边队尾

       Q.pop();Q.push('r');Q.push('t');Q.push(x); n出队，rtn入队，队里数据为：igrtn

       Q.pop();Q.push('s'); i出队，s入队，队里数据为：grtns

       while(!Q.empty()){} 队不空，在出队打印为：grtns

       cout<

    3. A

    分析：首先此题要保证入栈的顺序不能改变，其次，某个字母出栈前，必须把其栈顶的元素都要出栈

    A:e要先出栈，就必须把a b c d e 全部入栈，然后e才能出栈，对于e d 的出栈没有问题，只是a要出栈，就必须c d 先出栈后，才能轮到a出栈，因此A是不可能得到的出栈顺序，其他答案可以自行验证

    4. C

    分析:此题是一个层次遍历的伪代码，能够看出是层次遍历，其结果就迎刃而解

    4. 栈和队列的相关OJ题

    155. 最小栈 - 力扣（LeetCode）

    难度中等

    设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

    实现 MinStack 类:

    • MinStack() 初始化堆栈对象。

    • void push(int val) 将元素val推入堆栈。

    • void pop() 删除堆栈顶部的元素。

    • int top() 获取堆栈顶部的元素。

    • int getMin() 获取堆栈中的最小元素。

    示例 1:

    输入：
    ["MinStack","push","push","push","getMin","pop","top","getMin"]
    [[],[-2],[0],[-3],[],[],[],[]]

    输出：
    [null,null,null,null,-3,null,0,-2]

    解释：
    MinStack minStack = new MinStack();
    minStack.push(-2);
    minStack.push(0);
    minStack.push(-3);
    minStack.getMin();   --> 返回 -3.
    minStack.pop();
    minStack.top();      --> 返回 0.
    minStack.getMin();   --> 返回 -2.

    提示：

    • -2^31 <= val <= 2^31 - 1

    • pop、top 和 getMin 操作总是在 非空栈 上调用

    • push, pop, top, and getMin最多被调用 3 * 10^4 次

    1. class MinStack {
    2. public:
    3.     MinStack() {
    4.  
    5.     }
    6.     
    7.     void push(int val) {
    8.  
    9.     }
    10.     
    11.     void pop() {
    12.  
    13.     }
    14.     
    15.     int top() {
    16.  
    17.     }
    18.     
    19.     int getMin() {
    20.  
    21.     }
    22. };
    23.  
    24. /**
    25.  * Your MinStack object will be instantiated and called as such:
    26.  * MinStack* obj = new MinStack();
    27.  * obj->push(val);
    28.  * obj->pop();
    29.  * int param_3 = obj->top();
    30.  * int param_4 = obj->getMin();
    31.  */

    解析代码：

    思路：使用一个辅助栈，与元素栈同步插入与删除，用于存储与每个元素对应的最小值。 

    当一个元素要入栈时，我们取当前辅助栈的栈顶存储的最小值，

    与当前元素比较得出最小值将这个最小值插入辅助栈中；

    当一个元素要出栈时，我们把辅助栈的栈顶一样元素也一并弹出；

    在任意一个时刻，栈内元素的最小值就存储在辅助栈的栈顶元素中。

    给个图理解理解：

    1. class MinStack {
    2. public:
    3.     MinStack() { // 构造函数不用写，删掉也行
    4.  
    5.     }
    6.     
    7.     void push(int val) {
    8.         _st.push(val);
    9.         if(_minst.empty() || val <= _minst.top())//要先判空
    10.         {
    11.             _minst.push(val);//栈空或者值小于等于栈顶元素才入栈
    12.         }
    13.     }
    14.     
    15.     void pop() {
    16.         if(_st.top() == _minst.top())
    17.         {        //题目说栈空 不会调用pop，top和getMin，所以不判空也行
    18.             _minst.pop();//两个栈元素相等就_minst.pop
    19.         }
    20.         _st.pop();//要先判断_minst要不要pop
    21.     }
    22.     
    23.     int top() {
    24.         return _st.top();
    25.     }
    26.     
    27.     int getMin() {
    28.         return _minst.top();
    29.     }
    30. private:
    31.     stack<int> _st;// 一个栈完成常规接口
    32.     stack<int> _minst; // 一个栈完成getMin
    33. };
    34.  
    35. /**
    36.  * Your MinStack object will be instantiated and called as such:
    37.  * MinStack* obj = new MinStack();
    38.  * obj->push(val);
    39.  * obj->pop();
    40.  * int param_3 = obj->top();
    41.  * int param_4 = obj->getMin();
    42.  */

    拓展：如果面试的时候问到这题，面试官问你如果要插入的元素中包含大量的重复数据的话，

    比如100万个1，中间包含不一样的数，要怎么优化呢？

    这就考察到引用计数了。我们的辅助栈可以存一个结构体一个存值，一个计数：

     可以去写写，面试时也不一定要写，可能就是讲思路，主要是考察思维或不活跃。

    剑指 Offer 31. 栈的压入、弹出序列 - 力扣（LeetCode）

    946. 验证栈序列 - 力扣（LeetCode）

    栈的压入、弹出序列_牛客题霸_牛客网 (nowcoder.com)

    ps（上面三题是一模一样的，血赚两题）

    难度中等

    输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。

    假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，

    序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，

    但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。

    示例 1：

    输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
    输出：true
    解释：我们可以按以下顺序执行：
    push(1), push(2), push(3), push(4), pop() -> 4,
    push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1

    示例 2：

    输入：pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
    输出：false
    解释：1 不能在 2 之前弹出。

    提示：

    1. 0 <= pushed.length == popped.length <= 1000

    2. 0 <= pushed[i], popped[i] < 1000

    3. pushed 是 popped 的排列。

    1. class Solution {
    2. public:
    3.     bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
    4.  
    5.     }
    6. };

    解析代码：

    遍历两个数组，模拟入栈和出栈操作，判断两个数组是否为有效的栈操作序列。

    不求同年同月同日入栈，但求同年同月同日出栈：

    1. class Solution {
    2. public:
    3.     bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
    4.         if (pushed.size() != popped.size())
    5.         {
    6.             return false;
    7.         }
    8.         stack<int> st;
    9.         int popi = 0;//出栈序列的下标
    10.         for (const auto& e : pushed)//遍历入栈序列
    11.         {
    12.             st.push(e);//不匹配就持续入，匹配就持续出
    13.             while (!st.empty() && st.top() == popped[popi])
    14.             {
    15.                 st.pop();//一样的话就出栈，++popi
    16.                 ++popi;
    17.             }
    18.         }
    19.         //return popi == popped.size();//出栈序列全部匹配->true
    20.         return st.empty();//st为空->true
    21.     }
    22. };

    牛客代码：

    1. class Solution {
    2. public:
    3.     bool IsPopOrder(vector<int> pushV,vector<int> popV) {
    4.         if (pushV.size() != popV.size())
    5. 		{
    6. 			return false;
    7. 		}
    8.         stack<int> st;
    9.         int popi = 0;
    10.         for(const auto& e : pushV)
    11.         {
    12.             st.push(e);
    13.             while(!st.empty() && st.top() == popV[popi])
    14.             {
    15.                 st.pop();
    16.                 ++popi;
    17.             }
    18.         }
    19.         return st.empty();
    20.     }
    21. };

    150. 逆波兰表达式求值 - 力扣（LeetCode）

    难度中等

    给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

    请你计算该表达式。返回一个表示表达式值的整数。

    注意：

    • 有效的算符为 '+'、'-'、'*' 和 '/' 。

    • 每个操作数（运算对象）都可以是一个整数或者另一个表达式。

    • 两个整数之间的除法总是 向零截断 。

    • 表达式中不含除零运算。

    • 输入是一个根据逆波兰表示法表示的算术表达式。

    • 答案及所有中间计算结果可以用 32 位 整数表示。

    示例 1：

    输入：tokens = ["2","1","+","3","*"]
    输出：9
    解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

    示例 2：

    输入：tokens = ["4","13","5","/","+"]
    输出：6
    解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6

    示例 3：

    输入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
    输出：22
    解释：该算式转化为常见的中缀算术表达式为：
      ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
    = ((10 * (6 / (12 * -11))) + 17) + 5
    = ((10 * (6 / -132)) + 17) + 5
    = ((10 * 0) + 17) + 5
    = (0 + 17) + 5
    = 17 + 5
    = 22

    提示：

    • 1 <= tokens.length <= 10^4

    • tokens[i] 是一个算符（"+"、"-"、"*" 或 "/"），或是在范围 [-200, 200] 内的一个整数

    逆波兰表达式：

    逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。

    • 平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。

    • 该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

    逆波兰表达式主要有以下两个优点：

    • 去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。

    • 适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中

    1. class Solution {
    2. public:
    3.     int evalRPN(vector& tokens) {
    4.  
    5.     }
    6. };

    解析代码：

    思路：逆波兰表达式严格遵循「从左到右」的运算。计算逆波兰表达式的值时，

    使用一个栈存储操作数，从左到右遍历逆波兰表达式，进行如下操作：

    如果遇到操作数，则将操作数入栈；

    如果遇到运算符，则将两个操作数出栈，其中先出栈的是右操作数，

    后出栈的是左操作数，使用运算符对两个操作数进行运算，将运算得到的新操作数入栈。

    整个逆波兰表达式遍历完毕之后，栈内只有一个元素，该元素即为逆波兰表达式的值。

    简单来说就是：① 操作数入栈

    ② 遇到操作符就取栈顶两个操作数运算

    1. class Solution {
    2. public:
    3.     int evalRPN(vector& tokens) {
    4.         stack<int> st;
    5.         for(auto& e: tokens)
    6.         {
    7.             if(e == "+" || e == "-" || e == "*" || e == "/")
    8.             {
    9.                 int right = st.top();//右操作数先出栈
    10.                 st.pop();
    11.                 int left = st.top();
    12.                 st.pop();
    13.                 
    14.                 switch(e[0])
    15.                 {
    16.                     case '+':
    17.                         st.push(left + right);
    18.                         break;
    19.                     case '-':
    20.                         st.push(left - right);
    21.                         break;
    22.                     case '*':
    23.                         st.push(left * right);
    24.                         break;
    25.                     case '/':
    26.                         st.push(left / right);
    27.                         break;
    28.                 }
    29.             }
    30.             else
    31.             {
    32.                 st.push(stoi(e));
    33.             }
    34.         }
    35.         return st.top();
    36.     }
    37. };

    这题已经简化了，有可能给你一个中缀表达式：

    225. 用队列实现栈 - 力扣（LeetCode）

    难度简单

    请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

    实现 MyStack 类：

    • void push(int x) 将元素 x 压入栈顶。
    • int pop() 移除并返回栈顶元素。
    • int top() 返回栈顶元素。
    • boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

    注意：

    • 你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
    • 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

    示例：

    输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

    提示：

    • 1 <= x <= 9
    • 最多调用100 次 push、pop、top 和 empty
    • 每次调用 pop 和 top 都保证栈不为空

    进阶：你能否仅用一个队列来实现栈。

    1. class MyStack {
    2. public:
    3.     MyStack() {
    4.  
    5.     }
    6.     
    7.     void push(int x) {
    8.  
    9.     }
    10.     
    11.     int pop() {
    12.  
    13.     }
    14.     
    15.     int top() {
    16.  
    17.     }
    18.     
    19.     bool empty() {
    20.  
    21.     }
    22. };
    23.  
    24. /**
    25.  * Your MyStack object will be instantiated and called as such:
    26.  * MyStack* obj = new MyStack();
    27.  * obj->push(x);
    28.  * int param_2 = obj->pop();
    29.  * int param_3 = obj->top();
    30.  * bool param_4 = obj->empty();
    31.  */

    解析代码：法一（两个队列）

    这道题和下面的栈实现队列，以前都用C语言写过了，但现在我们换个思路

    以前的思路：（先入先出转为先入后出）

    1.入数据，往不为空的队列入，保持另一个队列为空

    2.出数据，依次出队头的数据，转移到另一个队列保存，只剩最后一个时Pop掉

    数据结构与算法⑨(第三章_下)队列的概念和实现(力扣：225+232+622)_GR C的博客-CSDN博客

    1. class MyStack {
    2. public:
    3.     queue<int> q1;
    4.     queue<int> q2;
    5.  
    6.     MyStack() {
    7.  
    8.     }
    9.     
    10. 	void push(int x) {
    11. 		q2.push(x); // q2入队列
    12. 		while (!q1.empty()) // 把q1的元素全入到q2
    13. 		{
    14. 			q2.push(q1.front());
    15. 			q1.pop();
    16. 		}
    17. 		swap(q1, q2); // 交换q1和q2
    18. 	}
    19.     
    20. 	int pop() {
    21. 		int r = q1.front();
    22. 		q1.pop();
    23. 		return r;
    24. 	}
    25.     
    26.     int top() {
    27.         //题目要求int top() 返回栈顶元素。（队列尾）队列不能删尾，能取尾
    28.         return q1.front();
    29.     }
    30.     
    31.     bool empty() {
    32.         return q1.empty();
    33.     }
    34. };

    解析代码：法二（一个队列）

    使用一个队列时，为了满足栈的特性，即最后入栈的元素最先出栈，同样需要满足队列前端的元素是最后入栈的元素。

    入栈操作时，首先获得入栈前的元素个数 n，然后将元素入队到队列，再将队列中的前 n 个元素（即除了新入栈的元素之外的全部元素）依次出队并入队到队列，此时队列的前端的元素即为新入栈的元素，且队列的前端和后端分别对应栈顶和栈底。

    由于每次入栈操作都确保队列的前端元素为栈顶元素，因此出栈操作和获得栈顶元素操作都可以简单实现。出栈操作只需要移除队列的前端元素并返回即可，获得栈顶元素操作只需要获得队列的前端元素并返回即可（不移除元素）。

    由于队列用于存储栈内的元素，判断栈是否为空时，只需要判断队列是否为空即可。

    1. class MyStack {
    2. public:
    3.     queue<int> q;
    4.  
    5.     MyStack() {
    6.  
    7.     }
    8.     
    9. 	void push(int x) {
    10. 		q.push(x);
    11.         int n = q.size() - 1;
    12.         while(n--)
    13.         {
    14.             q.push(q.front());
    15.             q.pop();
    16.         }
    17. 	}
    18.     
    19. 	int pop() {
    20. 		int r = q.front();
    21. 		q.pop();
    22. 		return r;
    23. 	}
    24.     
    25.     int top() {
    26.         //题目要求int top() 返回栈顶元素。（队列尾）队列不能删尾，能取尾
    27.         return q.front();
    28.     }
    29.     
    30.     bool empty() {
    31.         return q.empty();
    32.     }
    33. };

    232. 用栈实现队列 - 力扣（LeetCode）

    难度简单

    请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

    实现 MyQueue 类：

    • void push(int x) 将元素 x 推到队列的末尾
    • int pop() 从队列的开头移除并返回元素
    • int peek() 返回队列开头的元素
    • boolean empty() 如果队列为空，返回 true ；否则，返回 false

    说明：

    • 你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
    • 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

    示例 1：

    输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

    提示：

    • 1 <= x <= 9
    • 最多调用 100 次 push、pop、peek 和 empty
    • 假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）

    进阶：

    • 你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。
    1. class MyQueue {
    2. public:
    3.     MyQueue() {
    4.  
    5.     }
    6.     
    7.     void push(int x) {
    8.  
    9.     }
    10.     
    11.     int pop() {
    12.  
    13.     }
    14.     
    15.     int peek() {
    16.  
    17.     }
    18.     
    19.     bool empty() {
    20.  
    21.     }
    22. };
    23.  
    24. /**
    25.  * Your MyQueue object will be instantiated and called as such:
    26.  * MyQueue* obj = new MyQueue();
    27.  * obj->push(x);
    28.  * int param_2 = obj->pop();
    29.  * int param_3 = obj->peek();
    30.  * bool param_4 = obj->empty();
    31.  */

    解析代码：

    1. class MyQueue {
    2. public:
    3.     stack<int> inStack, outStack;
    4.  
    5.     MyQueue() {
    6.  
    7.     }
    8.     
    9.     void push(int x) {
    10.         inStack.push(x);
    11.     }
    12.     
    13.     int pop() {
    14.         if (outStack.empty())
    15.         {
    16.             while (!inStack.empty()) 
    17.             {
    18.                 outStack.push(inStack.top());
    19.                 inStack.pop();
    20.             }
    21.         }
    22.         int x = outStack.top();
    23.         outStack.pop();
    24.         return x;
    25.     }
    26.     
    27.     int peek() {
    28.         if (outStack.empty()) 
    29.         {
    30.             while (!inStack.empty()) 
    31.             {
    32.                 outStack.push(inStack.top());
    33.                 inStack.pop();
    34.             }
    35.         }
    36.         return outStack.top();
    37.     }
    38.     
    39.     bool empty() {
    40.         return inStack.empty() && outStack.empty();
    41.     }
    42. };

    本章完。

     下一部分先讲讲STL六大组件之一的容器适配器和双端队列deque和优先级队列priority_queue，再模拟实现stack和queue，最后模拟实现优先级队列priority_queue，

  • 相关阅读:
    反转链表系列
    Linux命令详解（10）-grep命令
    【Java基础】Java基础题
    链表增删操作问题及解决方法
    Linux入门第一天——linux基本概念
    【车载开发系列】ECU Application Software程序刷新步骤
    9月客户文章盘点——累计IF 103.2
    HTTP请求头
    策略模式优雅实践
    JAVA面经整理(8)
  • 原文地址：https://blog.csdn.net/GRrtx/article/details/130840176