Leetcode 39

im_AMBER

于 2025-10-26 23:05:31 发布

阅读量472

点赞数 17

CC 4.0 BY-SA版权

分类专栏： Leetcode 文章标签： leetcode 算法笔记学习

本文链接：https://blog.csdn.net/AYheyheyhey/article/details/153940779

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）的结构，就像排队，先到的先处理

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

一、整体思路

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

inStack（输入栈）：专门用来接收新加入的元素
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);                // 释放队列本身
}