Leetcode 39

1 题目

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] (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 操作）

进阶：

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

2 代码实现

一点也不会敲，不知道怎么弄。

typedef struct {int* stk;int stkSize;int stkCapacity;
} Stack;Stack* stackCreate(int cpacity) {Stack* ret = malloc(sizeof(Stack));ret->stk = malloc(sizeof(int) * cpacity);ret->stkSize = 0;ret->stkCapacity = cpacity;return ret;
}void stackPush(Stack* obj, int x) {obj->stk[obj->stkSize++] = x;
}void stackPop(Stack* obj) {obj->stkSize--;
}int stackTop(Stack* obj) {return obj->stk[obj->stkSize - 1];
}bool stackEmpty(Stack* obj) {return obj->stkSize == 0;
}void stackFree(Stack* obj) {free(obj->stk);
}typedef struct {Stack* inStack;Stack* outStack;
} MyQueue;MyQueue* myQueueCreate() {MyQueue* ret = malloc(sizeof(MyQueue));ret->inStack = stackCreate(100);ret->outStack = stackCreate(100);return ret;
}void in2out(MyQueue* obj) {while (!stackEmpty(obj->inStack)) {stackPush(obj->outStack, stackTop(obj->inStack));stackPop(obj->inStack);}
}void myQueuePush(MyQueue* obj, int x) {stackPush(obj->inStack, x);
}int myQueuePop(MyQueue* obj) {if (stackEmpty(obj->outStack)) {in2out(obj);}int x = stackTop(obj->outStack);stackPop(obj->outStack);return x;
}int myQueuePeek(MyQueue* obj) {if (stackEmpty(obj->outStack)) {in2out(obj);}return stackTop(obj->outStack);
}bool myQueueEmpty(MyQueue* obj) {return stackEmpty(obj->inStack) && stackEmpty(obj->outStack);
}void myQueueFree(MyQueue* obj) {stackFree(obj->inStack);stackFree(obj->outStack);
}

• 栈：是 “后进先出”（LIFO）的结构，就像叠盘子，最后放上去的要先拿下来
• 队列：是 “先进先出”（FIFO）的结构，就像排队，先到的先处理

题目要求用栈来实现队列的功能，这就需要一些技巧了。

一、整体思路

这里用了两个栈来模拟队列：

1. inStack（输入栈）：专门用来接收新加入的元素
2. outStack（输出栈）：专门用来提供出队和查看队首的操作

关键逻辑：当需要出队或查看队首时，如果输出栈为空，就把输入栈的所有元素转移到输出栈中。这样输出栈的顶部就是最早加入的元素（符合队列特性）。

二、代码拆解

1. 栈的实现（辅助结构）

因为 C 语言没有内置栈，所以先实现一个简单的栈结构：

typedef struct {int* stk;          // 存储栈元素的数组int stkSize;       // 当前栈中元素的数量int stkCapacity;   // 栈的最大容量
} Stack;

栈的基本操作：

• stackCreate：创建一个栈（初始化内存）
• stackPush：向栈顶添加元素（stkSize 加 1）
• stackPop：移除栈顶元素（stkSize 减 1，不用真的删除数据）
• stackTop：返回栈顶元素（取 stk [stkSize-1]）
• stackEmpty：判断栈是否为空（stkSize 是否为 0）
• stackFree：释放栈占用的内存

2. 队列的实现（核心结构）

用两个栈组成队列：

typedef struct {Stack* inStack;   // 输入栈Stack* outStack;  // 输出栈
} MyQueue;

3. 关键函数解析

（1）创建队列 myQueueCreate

MyQueue* myQueueCreate() {MyQueue* ret = malloc(sizeof(MyQueue));ret->inStack = stackCreate(100);   // 创建输入栈ret->outStack = stackCreate(100);  // 创建输出栈return ret;
}

• 分配队列的内存
• 初始化两个栈（容量暂设为 100）

（2）转移元素 in2out（核心逻辑）

void in2out(MyQueue* obj) {while (!stackEmpty(obj->inStack)) {  // 当输入栈不为空时// 把输入栈的栈顶元素压入输出栈stackPush(obj->outStack, stackTop(obj->inStack));// 移除输入栈的栈顶元素stackPop(obj->inStack);}
}

• 作用：把输入栈的所有元素 “倒” 到输出栈中
• 举例：输入栈有 [1,2,3]（1 在底，3 在顶），转移后输出栈变成 [3,2,1]（3 在底，1 在顶），此时输出栈的顶部就是最早加入的 1

（3）入队操作 myQueuePush

void myQueuePush(MyQueue* obj, int x) {stackPush(obj->inStack, x);  // 直接把元素压入输入栈
}

• 非常简单，因为输入栈就是用来接收新元素的
• 比如：调用 myQueuePush(q, 1)，输入栈就变成 [1]

（4）出队操作 myQueuePop

int myQueuePop(MyQueue* obj) {if (stackEmpty(obj->outStack)) {  // 如果输出栈为空in2out(obj);                  // 先把输入栈的元素转移过来}int x = stackTop(obj->outStack);  // 取输出栈的顶部元素（队首）stackPop(obj->outStack);          // 移除输出栈的顶部元素return x;
}

• 步骤：
  1. 检查输出栈是否为空，如果空就转移输入栈的元素
  2. 取输出栈的顶部元素（这是最早加入的元素）
  3. 移除这个元素并返回
• 举例：
  • 输入栈有 [1,2,3]，输出栈为空
  • 调用 myQueuePop 时，先执行 in2out，输出栈变成 [3,2,1]（1 在顶）
  • 取出 1 并移除，输出栈变成 [3,2]

（5）查看队首 myQueuePeek

int myQueuePeek(MyQueue* obj) {if (stackEmpty(obj->outStack)) {  // 和出队类似，先检查输出栈in2out(obj);}return stackTop(obj->outStack);   // 只返回顶部元素，不移除
}

（6）判断队列是否为空 myQueueEmpty

bool myQueueEmpty(MyQueue* obj) {// 只有两个栈都为空时，队列才为空return stackEmpty(obj->inStack) && stackEmpty(obj->outStack);
}

（7）释放队列 myQueueFree

void myQueueFree(MyQueue* obj) {stackFree(obj->inStack);  // 释放输入栈stackFree(obj->outStack); // 释放输出栈free(obj);                // 释放队列本身
}

三、举例理解整个流程

假设我们执行以下操作：

1. 创建队列 q = myQueueCreate()
2. 入队：myQueuePush(q, 1) → 输入栈 [1]，输出栈 []
3. 入队：myQueuePush(q, 2) → 输入栈 [1,2]，输出栈 []
4. 查看队首：myQueuePeek(q) → 输出栈为空，执行 in2out，输入栈变空，输出栈 [2,1]，返回 1
5. 出队：myQueuePop(q) → 输出栈顶部是 1，移除后输出栈 [2]，返回 1
6. 入队：myQueuePush(q, 3) → 输入栈 [3]，输出栈 [2]
7. 出队：myQueuePop(q) → 输出栈不为空，直接取 2，输出栈变空，返回 2
8. 出队：myQueuePop(q) → 输出栈为空，执行 in2out，输入栈的 3 转移到输出栈，输出栈 [3]，取 3 返回

四、复杂度分析

• 时间复杂度：
  • push 和 empty 是 O (1)（直接操作）
  • pop 和 peek 是均摊 O (1)（每个元素最多转移一次，整体平均下来是 O (1)）
• 空间复杂度：O (n)（需要存储 n 个元素）