题目

标题和出处

标题：用队列实现栈

出处：225. 用队列实现栈

难度

4 级

题目描述

要求

请你仅使用两个队列实现一个后进先出的栈。实现的栈应该支持普通栈的全部操作（$\text{push}$、$\text{pop}$、$\text{top}$ 和 $\text{empty}$）。

实现 $\text{MyStack}$ 类：

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

注意：

• 你只能使用队列的基本操作，只有在队尾添加元素、在队首查看和删除元素、返回元素个数和判断是否为空的操作是有效的。
• 你所使用的语言也许不支持队列。你可以使用列表或者双端队列来模拟一个队列，只要所有的操作都是标准的队列操作即可。

示例

示例 1：

输入：
$\text{["MyStack", "push", "push", "top", "pop", "empty"]}$
$\text{[[], [1], [2], [], [], []]}$
输出：
$\text{[null, null, null, 2, 2, false]}$
解释：
$\text{MyStack myStack = new MyStack();}$
$\text{myStack.push(1);}$
$\text{myStack.push(2);}$
$\text{myStack.top();}$ // 返回 $\text{2}$
$\text{myStack.pop();}$ // 返回 $\text{2}$
$\text{myStack.empty();}$ // 返回 $\text{False}$

数据范围

• $\text{1}\le \text{x}\le \text{9}$
• 最多调用 $\text{100}$ 次 $\text{push}$、$\text{pop}$、$\text{top}$ 和 $\text{empty}$
• 每次调用 $\text{pop}$ 和 $\text{top}$ 都是有效的

进阶

你能否仅使用一个队列实现栈？

解法一

思路和算法

由于栈的特点是后进先出，因此使用队列实现栈时，需要维护队列内的元素顺序，使得队首元素是最后入队的元素。

使用两个队列实现时，${\text{queue}}_1$ 的作用是存储元素，${\text{queue}}_2$ 的作用是辅助操作。

为了实现栈的功能，需要保证每次入栈操作之后，${\text{queue}}_1$ 的队首元素总是新添加的元素。因此入栈操作如下：

1. 将待添加的元素入队到 ${\text{queue}}_2$；

2. 将 ${\text{queue}}_1$ 的全部元素依次出队并入队到 ${\text{queue}}_2$；

3. 将 ${\text{queue}}_1$ 和 ${\text{queue}}_2$ 互换。

完成上述操作后，${\text{queue}}_2$ 为空，${\text{queue}}_1$ 的队首元素是新添加的元素，${\text{queue}}_1$ 内的其余元素和顺序不变。因此上述操作的效果是在 ${\text{queue}}_1$ 的队首增加了新添加的元素，${\text{queue}}_1$ 的队首和队尾分别对应栈顶和栈底。

由于每次入栈操作都维护了 ${\text{queue}}_1$ 内的元素顺序，因此出栈操作和查看栈顶元素操作可以简单实现。出栈操作只需要将 ${\text{queue}}_1$ 的队首元素移除并返回即可，查看栈顶元素操作只需要返回 ${\text{queue}}_1$ 的队首元素即可。

由于 ${\text{queue}}_1$ 的作用是存储元素，因此判断栈是否为空操作只需要判断 ${\text{queue}}_1$ 是否为空即可。

代码

class MyStack {
    Queue<Integer> queue1;
    Queue<Integer> queue2;

    public MyStack() {
        queue1 = new ArrayDeque<Integer>();
        queue2 = new ArrayDeque<Integer>();
    }

    public void push(int x) {
        queue2.offer(x);
        while (!queue1.isEmpty()) {
            queue2.offer(queue1.poll());
        }
        Queue<Integer> temp = queue1;
        queue1 = queue2;
        queue2 = temp;
    }

    public int pop() {
        return queue1.poll();
    }

    public int top() {
        return queue1.peek();
    }

    public boolean empty() {
        return queue1.isEmpty();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

复杂度分析

• 时间复杂度：构造方法的时间复杂度是 $O(1)$，入栈操作的时间复杂度是 $O(n)$，出栈、查看栈顶元素和判断栈是否为空操作的时间复杂度都是 $O(1)$，其中 $n$ 是栈内元素个数。
  入栈操作需要将 ${\text{queue}}_1$ 的 $n$ 个元素出队，并将 $n+1$ 个元素入队到 ${\text{queue}}_2$，共有 $2n+1$ 次操作，每次出队和入队操作的时间复杂度都是 $O(1)$，因此入栈操作的时间复杂度是 $O(n)$。
  出栈、查看栈顶元素和判断栈是否为空操作都是常规队列操作，时间复杂度都是 $O(1)$。

• 空间复杂度：$O(n)$，其中 $n$ 是栈内元素个数。需要使用队列存储元素。

解法二

思路和算法

也可以使用一个队列实现栈。

使用一个队列实现时，同样需要维护队列内的元素顺序，使得队首元素是最后入队的元素，因此需要保证每次入栈操作之后，队首元素总是新添加的元素。

使用一个队列实现的入栈操作和使用两个队列实现的入栈操作有所区别，由于只有一个队列，所有的元素都需要存储在队列内。入栈操作如下：

1. 计算队列内的元素个数 $\text{size}$；

2. 将待添加的元素入队；

3. 将队列内的前 $\text{size}$ 个元素依次出队并入队。

完成上述操作后，队首元素是新添加的元素，队列内的其余元素和顺序不变。因此上述操作的效果是在队首增加了新添加的元素，队首和队尾分别对应栈顶和栈底。

出栈操作、查看栈顶元素操作和判断栈是否为空操作和解法一相同，只需要在队列上执行相应操作即可。

代码

class MyStack {
    Queue<Integer> queue;

    public MyStack() {
        queue = new ArrayDeque<Integer>();
    }

    public void push(int x) {
        int size = queue.size();
        queue.offer(x);
        for (int i = 0; i < size; i++) {
            queue.offer(queue.poll());
        }
    }

    public int pop() {
        return queue.poll();
    }

    public int top() {
        return queue.peek();
    }

    public boolean empty() {
        return queue.isEmpty();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

复杂度分析

• 时间复杂度：构造方法的时间复杂度是 $O(1)$，入栈操作的时间复杂度是 $O(n)$，出栈、查看栈顶元素和判断栈是否为空操作的时间复杂度都是 $O(1)$，其中 $n$ 是栈内元素个数。
  入栈操作需要将队列的 $n$ 个元素出队，并将 $n+1$ 个元素入队，共有 $2n+1$ 次操作，每次出队和入队操作的时间复杂度都是 $O(1)$，因此入栈操作的时间复杂度是 $O(n)$。
  出栈、查看栈顶元素和判断栈是否为空操作都是常规队列操作，时间复杂度都是 $O(1)$。

• 空间复杂度：$O(n)$，其中 $n$ 是栈内元素个数。需要使用队列存储元素。