用双栈实现队列：数据结构转换的经典解法

1. 栈与队列的基本概念解析

在数据结构的世界里，栈(Stack)和队列(Queue)就像是一对性格迥异的双胞胎。栈遵循LIFO（Last In First Out）原则，就像我们叠放的一摞盘子，最后放上去的总是最先被取用；而队列则遵循FIFO（First In First Out）原则，更像是排队买奶茶的场景，先来的人先获得服务。

这个题目之所以经典，是因为它要求我们用栈这种"后进先出"的结构，模拟出队列"先进先出"的行为。这就好比要用一个只能从顶部放入和取出物品的箱子，模拟出两端都能操作的管道——看似矛盾的需求背后，其实蕴含着精妙的设计思路。

2. 双栈法的设计原理

2.1 核心思路拆解

实现这个"魔法"的关键在于使用两个栈——我们暂且称它们为输入栈(inputStack)和输出栈(outputStack)。当需要执行队列的push操作时，我们直接将元素压入输入栈；当需要执行pop或peek操作时，如果输出栈为空，我们就把输入栈的所有元素依次弹出并压入输出栈，这样原本在输入栈底的元素就到了输出栈顶。

这个过程就像把一摞书从左手倒到右手——原本在最下面的书现在跑到了最上面。通过这种巧妙的"倒腾"，我们实现了元素的顺序反转，从而用栈模拟出了队列的行为。

2.2 时间复杂度分析

这种设计的美妙之处在于它的均摊时间复杂度：

• push操作：O(1) - 直接压入输入栈
• pop/peek操作：均摊O(1) - 虽然偶尔需要将输入栈全部倒入输出栈（O(n)），但每个元素最多被移动两次（进输入栈一次，进输出栈一次），所以均摊下来仍然是常数时间

3. 具体实现步骤详解

3.1 类结构设计

python复制class MyQueue:
    def __init__(self):
        self.input_stack = []
        self.output_stack = []

我们首先定义MyQueue类，初始化两个空栈。这里使用Python的list来模拟栈的行为，因为list的append和pop操作正好对应栈的push和pop。

3.2 push操作实现

python复制def push(self, x: int) -> None:
    self.input_stack.append(x)

push操作极其简单——直接将新元素追加到input_stack的末尾。这就是标准的栈push操作，时间复杂度O(1)。

3.3 pop操作实现

python复制def pop(self) -> int:
    if not self.output_stack:
        while self.input_stack:
            self.output_stack.append(self.input_stack.pop())
    return self.output_stack.pop()

pop操作稍微复杂些：

1. 首先检查output_stack是否为空
2. 如果为空，就将input_stack的所有元素依次弹出并压入output_stack
3. 最后弹出output_stack的栈顶元素并返回

关键点：只有当output_stack为空时，才需要从input_stack"倒货"，这样可以确保每个元素只被移动两次，保证均摊时间复杂度。

3.4 peek操作实现

python复制def peek(self) -> int:
    if not self.output_stack:
        while self.input_stack:
            self.output_stack.append(self.input_stack.pop())
    return self.output_stack[-1]

peek操作与pop类似，只是不实际移除元素。同样需要先确保output_stack不为空，然后返回栈顶元素而不弹出。

3.5 empty操作实现

python复制def empty(self) -> bool:
    return not self.input_stack and not self.output_stack

判断队列是否为空很简单——只需检查两个栈是否都为空即可。

4. 边界条件与异常处理

在实际编码中，我们需要特别注意几个边界情况：

1. 连续push后立即peek：确保能正确看到最早进入的元素
2. 交替push和pop：验证元素顺序是否正确
3. 空队列时的pop/peek：题目保证不会出现，但实际工程中需要处理
4. 大规模数据测试：验证均摊时间复杂度的有效性

5. 复杂度优化与变种思考

虽然双栈法已经相当高效，但我们还可以思考一些优化方向：

1. 延迟转移策略：只有当需要pop/peek且output_stack为空时才转移元素，减少不必要的操作
2. 空间利用率：最坏情况下需要O(n)额外空间，但实际使用中往往好于最坏情况
3. 多栈实现：理论上可以用更多栈来模拟队列，但双栈已经是最优解

6. 实际应用场景举例

这种栈模拟队列的技术在实际中有许多妙用：

1. 浏览器历史记录：需要同时支持前进和后退操作
2. 撤销/重做功能：某些编辑器需要更复杂的操作顺序管理
3. 消息队列系统：在资源受限环境下可能需要类似的实现技巧
4. 递归算法改写：有时需要将递归改为迭代，这种结构很有帮助

7. 常见错误与调试技巧

在实现过程中，新手常会遇到这些问题：

1. 忘记在pop/peek前检查output_stack是否为空，导致顺序错误
2. 在转移元素时搞错弹出顺序，破坏了FIFO特性
3. 错误计算时间复杂度，误以为每次pop都是O(n)
4. 忽视空队列情况的处理（虽然本题不需要）

调试时可以：

1. 手动模拟小规模操作序列
2. 打印两个栈的状态辅助理解
3. 编写单元测试覆盖各种操作组合
4. 使用可视化工具观察数据流动

8. 扩展思考：用队列实现栈

作为反向思考，LeetCode也有用队列实现栈的题目（225题）。这两种题目常常成对出现，建议对比学习。用队列实现栈的核心思路是：

1. 使用一个主队列和一个辅助队列
2. 每次push时，先入队到辅助队列，再将主队列元素全部转移到辅助队列
3. 最后交换两个队列的角色
4. 这样新元素总是位于队列前端，实现了LIFO

这种实现方式push是O(n)，pop是O(1)，正好与栈模拟队列的情况形成有趣对比。