【简单】力扣算法题解析LeetCode232：用栈实现队列

关注文末推广名片，即可免费获得本题测试源码！

题目来源：LeetCode232：用栈实现队列

问题抽象： 设计队列数据结构，仅使用两个栈实现队列的所有核心操作（先进先出），满足以下核心需求：

1. 功能要求：

   • 实现 MyQueue 类：
     • void push(int x)：队尾插入元素；
     • int pop()：移除并返回队首元素；
     • int peek()：返回队首元素（不移除）；
     • boolean empty()：判断队列是否为空。

2. 实现约束：

   • 仅允许使用栈的标准操作（push/pop/peek/size/isEmpty）；
   • 必须通过两个栈（Stack 或 Deque 模拟栈）实现；
   • 所有操作需满足 均摊时间复杂度 O(1)（n 次操作总代价 O(n)）。

3. 核心设计规则：

   • 双栈分工：
     • inStack：专用于 push 操作；
     • outStack：专用于 pop 和 peek 操作；
   • 数据迁移条件：当 outStack 为空时，将 inStack 所有元素一次性转移到 outStack（逆转元素顺序）。

4. 边界保证：

   • 对空队列调用 pop 或 peek 时，题目保证操作有效（无需额外处理）；
   • 元素类型为整数（32 位有符号整数）；
   • 最多调用 100 次 push、pop、peek、empty。

输入输出示例：

MyQueue obj = new MyQueue();  
obj.push(1);      // 队列: [1]  
obj.push(2);      // 队列: [1,2]  
int a = obj.peek(); // 返回 1  
int b = obj.pop();  // 返回 1，队列: [2]  
boolean c = obj.empty(); // 返回 false  

解题思路

使用两个栈 inStack（输入栈）和 outStack（输出栈）实现队列：

1. push(x)：
   直接将元素压入 inStack，时间复杂度 O(1)。

2. pop() 和 peek()：

   • 若 outStack 为空，则将 inStack 的所有元素依次弹出并压入 outStack（此时 outStack 的栈顶即为队列头部）。
   • 从 outStack 弹出（pop）或查看（peek）栈顶元素。
     均摊时间复杂度 O(1)：每个元素最多经历一次从 inStack 到 outStack 的转移，均摊成本为 O(1)。

3. empty()：
   当且仅当两个栈均为空时队列为空，时间复杂度 O(1)。

代码实现（Java版）🔥点击下载源码

import java.util.Stack;

class MyQueue {
    private final Stack<Integer> inStack;  // 输入栈（尾部操作）
    private final Stack<Integer> outStack; // 输出栈（头部操作）

    public MyQueue() {
        inStack = new Stack<>();
        outStack = new Stack<>();
    }
    
    // 将元素添加到队列尾部
    public void push(int x) {
        inStack.push(x); // 直接压入输入栈
    }
    
    // 移除并返回队列头部元素
    public int pop() {
        transferIfNeeded(); // 确保输出栈有数据
        return outStack.pop(); // 弹出输出栈顶部
    }
    
    // 返回队列头部元素（不移除）
    public int peek() {
        transferIfNeeded(); // 确保输出栈有数据
        return outStack.peek(); // 查看输出栈顶部
    }
    
    // 判断队列是否为空
    public boolean empty() {
        return inStack.isEmpty() && outStack.isEmpty(); // 两栈皆空
    }
    
    // 辅助方法：若输出栈为空，将输入栈所有元素转移到输出栈
    private void transferIfNeeded() {
        if (outStack.isEmpty()) {
            while (!inStack.isEmpty()) {
                outStack.push(inStack.pop()); // 倒序转移元素
            }
        }
    }
}

代码说明

1. 双栈分工：

   • inStack 处理新元素入队（push）。
   • outStack 处理头部元素出队（pop/peek），通过倒序转移保证队列的 FIFO 特性。

2. 高效均摊：

   • push 直接操作 inStack，O(1) 时间。
   • pop/peek 在 outStack 为空时触发一次 O(n) 转移，但每个元素最多转移一次，均摊 O(1)。

3. 空队列判断：
   empty() 检查两栈是否均为空，O(1) 时间。

提交详情（执行用时、内存消耗）