232. 用栈实现队列-CSDN博客

本文链接：https://blog.csdn.net/weixin_38279101/article/details/114399605

文章目录

有什么不懂的地方欢迎留言！

题目描述

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列的支持的所有操作（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（双端队列）来模拟一个栈，只要是标准的栈操作即可。

进阶：

你能否实现每个操作均摊时间复杂度为 O(1)的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。

示例：

输入：
["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 操作）

来源：力扣（LeetCode）：https://leetcode-cn.com/problems/implement-queue-using-stacks

解题思路一

队列是一种先进先出（first in - first out， FIFO）的数据结构，队列中的元素都从后端（rear）入队（push），从前端（front）出队（pop）。如下图所示：在这里插入图片描述

        栈是一种后进先出（last in - first out， LIFO）的数据结构，栈中元素从栈顶（top）压入（push)，也从栈顶弹出（pop）。如下图所示：
在这里插入图片描述
        因为队列是先进先出的，而栈是后进先出的，所以最新压入的元素需要放在栈底才能做到与队列中的顺序一样！
        第一步，需要把栈s1中所有的元素移动到栈s2中，接着把新元素压入s2中，第二步，再把s2中所有的元素弹出，再把弹出的元素压入到s1中，此时元素的顺序才和队列中的顺序一样！
        此时有两个栈，和四个元素，要如何才能做到像队列中的顺序一样呢？

（一）入队操作（push）
在这里插入图片描述
        第一步，栈s1为空，把元素压入栈s1中

        第二步，压入新元素 “2” ，为了做到栈s1中的元素顺序与队列中的元素出队顺序一样，需要先把元素1从栈s1中弹出，并且压入栈s2中，然后再将元素2压入栈s2中，最后再把元素2和元素1从栈s2中弹出，然后压入栈s1中
在这里插入图片描述
        第三步，压入新元素 “3” ，首先需要先把元素1和元素2从栈s1中弹出，并且压入栈s2中，然后再将元素3压入栈s2中，最后再把元素3、元素2和元素1从栈s2中弹出，然后压入栈s1中
第四个元素就不画了，作图太累了=_= !

        最后，为了代码上的统一，把初始时，元素1直接压入栈s1，也改为先压入栈s2中，然后再弹出，再压入栈s1中
在这里插入图片描述
（二）出队操作（pop）
        直接从 s1 弹出就可以了，因为 s1 的栈顶元素就是队列的队首元素。同时我们把弹出之后 s1 的栈顶元素赋值给代表队首元素的 front 变量即可。
（三）取队首元素（peek）
        在我们的算法中，用了 front 变量来存储队首元素，在每次入队操作或者出队操作之后这个变量都会随之更新。
（四）判断空（empty）
        s1 存储了队列所有的元素，所以只需要检查 s1 的是否为空就可以了。

代码

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

class MyQueue {
private:
    stack<int> Stack_s1, Stack_s2;
    int front;

public:
    /** 默认构造函数初始化 */
    MyQueue() {

    }

    /**  将元素x推到队列的后面。*/
    void push(int x) {
        if (Stack_s1.empty()) {
            front = x;
        }
        while (!Stack_s1.empty()) {
            Stack_s2.push(Stack_s1.top());
            Stack_s1.pop();
        }
        Stack_s2.push(x);
        while (!Stack_s2.empty()) {
            Stack_s1.push(Stack_s2.top());
            Stack_s2.pop();
        }
    }

    /**  从队头删除元素并返回该元素。*/
    int pop() {
        if (!Stack_s1.empty()) {        //有元素则弹出栈顶元素，并且返回栈顶元素
            front = Stack_s1.top();
            Stack_s1.pop();
        }
        else {
            return -1;                      //没有元素则返回-1
        }
        return front;
    }

    /**  获取队头元素，注意，此时所有元素都在栈s1中，且出队顺序都和在队列中的顺序一样*/
    int peek() {
        if (Stack_s1.empty()) {         //没有元素则返回-1
            return -1;
        }
        return Stack_s1.top();           //有元素则返回栈顶元素
    }

    /**  判断队列是否为空*/
    bool empty() {
        //因为所有数据最终都在栈s1中，所以只需判断栈s1是否为空即可
        return Stack_s1.empty();        
    }
};

int main() {
    MyQueue myqueue;
    myqueue.push(1);
    myqueue.push(2);
   
        cout << "peek：" << myqueue.peek() << endl;;
    myqueue.pop();
    if (myqueue.empty()) {
        cout << "true" << endl;         //true表示队列为空
    }
    else {
        cout << "false" << endl;         //false表示队列为空
    }
    
    system("pause");
    return 0;
}

运行结果
在这里插入图片描述

解题思路二

（一）入队操作（push）
        新元素总是压入 s1 的栈顶
在这里插入图片描述
（二）出队操作（pop）
        根据栈(先进后出)的特性，s1 中第一个压入的元素在栈底。为了弹出 s1 的栈底元素，我们得把 s1 中所有的元素全部弹出，再把它们压入到另一个栈 s2 中，这个操作会让元素的入栈顺序反转过来。通过这样的方式，s1 中栈底元素就变成了 s2 的栈顶元素，这样就可以直接从 s2 将它弹出了。一旦 s2 变空了，我们只需把 s1 中的元素再一次转移到 s2 就可以了。
在这里插入图片描述
（三）取队首元素（peek）
        当 s2 为空，则把栈s1中的元素压入栈s2中，当 s2 非空，s2 的栈顶元素就是队首元素。
（四）判断空（empty）
        s1 和 s2 都存有队列的元素，所以只需要检查 s1 和 s2 是否都为空就可以了。

代码

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

class MyQueue {
private:
    stack<int> stack_s1, stack_s2;

public:
    /** 默认构造函数初始化 */
    MyQueue() {

    }

    /**  入队操作*/
    void push(int x) {
        stack_s1.push(x);           //直接把元素压入栈s1即可
    }

    /**  出队操作，为了做到与出队的顺序一致，需要把栈s1的元素压入栈s2中，再从栈s2弹出即可*/
    int pop() {
        if (stack_s2.empty()) {
            while (!stack_s1.empty()) {                     //把栈s1的数据弹出，然后压入栈s2中
                stack_s2.push(stack_s1.top());
                stack_s1.pop();
            }
        }
        int x = stack_s2.top();                             //元素出队，直接从栈s2中弹出栈顶元素即可
        stack_s2.pop();
        return x;
    }

    /**  获取队头元素*/
    int peek() {
        if (stack_s2.empty()) {
            while (!stack_s1.empty()) {             //如果栈s2为空，则把栈s1中的元素压入栈s2中
                stack_s2.push(stack_s1.top());
                stack_s1.pop();
            }
        }
        return stack_s2.top();                        //获取栈s2的栈顶元素，即为队头元素
    }

    /**  判断队列是否为空*/
    bool empty() {
        //因为此时两个栈都有元素，所以需要判断两个栈是否都为空才行
        return stack_s1.empty() && stack_s2.empty();
    }
};

 int main() {
     MyQueue myqueue;
     myqueue.push(1);
     myqueue.push(2);
    
         cout << "peek：" << myqueue.peek() << endl;;
     myqueue.pop();
     if (myqueue.empty()) {
         cout << "true" << endl;         //true表示队列为空
     }
     else {
         cout << "false" << endl;         //false表示队列为空
     }
     
     system("pause");
     return 0;
 }