栈和队列相互成全

请享受无法回避的痛苦

232.用两个栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（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] (leftm ost 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) ，即使其中一个操作可能花费较长时间。

思路分析

• 比如有一串字母abc

• 先把abc,依次放入in栈

• 再把in栈的元素倒入out栈，每次要倒完

• 3最后out栈再出，每次要倒完

完整代码

class MyQueue {
private:
    stack<int> in;  // 用于入队的栈
    stack<int> out; // 用于出队的栈
   
public:
    // 构造函数
    MyQueue() {}
    //倒数据
    //从in栈，把数据倒入out栈
    //1.out空了，才能倒数据
    //2.如果倒数据，in必须倒完
    void inToOut(){
        if(out.empty()){
            while(!in.empty()){
                out.push(in.top());
                in.pop();
            }
        }
    }
    // 将元素 x 入队
    void push(int x) {
        in.push(x);//先加入，然后看是否要倒数据
        inToOut();
    }

    // 弹出队首元素
    int pop() {
        inToOut();//先看是否要倒数据，倒完数据再弹出队首元素
        int x=out.top();
        out.pop();
        return x;
    }

    // 查看队首元素
    int peek() {
        inToOut();//先看是否要倒数据，倒完数据再查看队首元素
        return out.top();
    }

    // 判断队列是否为空
    // 当 inStack 和 outStack 都为空时，队列为空
    bool empty() {
        return in.empty() && out.empty();  
    }
};

225.用一个队列实现栈

请你仅使用两个队列实现一个后入先出（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 都保证栈不为空

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

思路分析

• 主要是push操作，如何思考

• push操作：比如a已经进栈了，现在要进b

• 在b进入之前，先记录下队列里面有多少元素，有1个

• 然后执行操作：把队头元素加入到队尾，执行上面所记录的元素次，比如说上面记录的元素个数是3，就执行3次这样的操作。

完整代码

class MyStack {
private:
    queue<int> q; // 用于存储栈元素的队列

public:
    // 构造函数，初始化队列
    MyStack() {}

    // 将元素 x 推入栈中（时间复杂度 O(n)）
    void push(int x) {
        int n = q.size(); // 获取当前队列中的元素数量
        q.push(x);        // 将新元素 x 加入队列

        // 将队列中的元素重新排列，以保持栈的性质
        for (int i = 0; i < n; i++) {
            q.push(q.front()); // 将队首元素移动到队列尾部
            q.pop();               // 弹出队首元素
        }
    }

    // 弹出栈顶元素
    int pop() {

        auto x =q .front(); // 获取队首元素（栈顶元素）
        q.pop();            // 弹出队首元素
        return x;
    }

    // 返回栈顶元素
    int top() {
        return q.front(); // 返回队首元素（栈顶元素），不移除
    }

    // 检查栈是否为空
    bool empty() {
        return q.empty(); // 如果队列为空，则栈为空
    }
};