225. 用队列实现栈

题目

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

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

注意：

• 你只能使用队列的标准操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
• 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

输入：
[“MyStack”, “push”, “push”, “top”, “pop”, “empty”]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

提示：

• 1 <= x <= 9
• 最多调用100 次 push、pop、top 和 empty
• 每次调用 pop 和 top 都保证栈不为空

解题思路

弹出元素时调整：保持正常入队，但在出栈操作时，将队列中除了最后一个元素外的所有元素转移到另一个队列，然后返回最后一个元素。之后再将两个队列的角色交换。

代码

// 定义队列结构
typedef struct {int* data;int front;int rear;int size;      // 当前元素个数int capacity;
} Queue;// 创建队列
Queue* queueCreate(int capacity) {Queue* queue = (Queue*)malloc(sizeof(Queue));queue->data = (int*)malloc(sizeof(int) * capacity);queue->front = 0;queue->rear = 0;queue->size = 0;queue->capacity = capacity;return queue;
}// 入队
void queuePush(Queue* queue, int x) {if (queue->size == queue->capacity) {// 队列已满，需要扩容int newCapacity = queue->capacity * 2;int* newData = (int*)malloc(sizeof(int) * newCapacity);// 复制原有元素到新数组for (int i = 0; i < queue->size; i++) {newData[i] = queue->data[(queue->front + i) % queue->capacity];}free(queue->data);queue->data = newData;queue->front = 0;queue->rear = queue->size;queue->capacity = newCapacity;}queue->data[queue->rear] = x;queue->rear = (queue->rear + 1) % queue->capacity;queue->size++;
}// 出队
int queuePop(Queue* queue) {int val = queue->data[queue->front];queue->front = (queue->front + 1) % queue->capacity;queue->size--;return val;
}// 获取队首元素
int queuePeek(Queue* queue) {return queue->data[queue->front];
}// 判断队列是否为空
bool queueEmpty(Queue* queue) {return queue->size == 0;
}// 获取队列中元素个数
int queueSize(Queue* queue) {return queue->size;
}// 释放队列内存
void queueFree(Queue* queue) {free(queue->data);free(queue);
}// 定义栈结构（使用两个队列）
typedef struct {Queue* queue1;Queue* queue2;
} MyStack;// 创建栈
MyStack* myStackCreate() {MyStack* stack = (MyStack*)malloc(sizeof(MyStack));stack->queue1 = queueCreate(10);  // 初始容量较小，会根据需要自动扩容stack->queue2 = queueCreate(10);return stack;
}// 入栈操作
void myStackPush(MyStack* obj, int x) {queuePush(obj->queue1, x);
}// 出栈操作
int myStackPop(MyStack* obj) {int size = queueSize(obj->queue1);for (int i = 0; i < size - 1; i++) {queuePush(obj->queue2, queuePop(obj->queue1));}int top = queuePop(obj->queue1);Queue* temp = obj->queue1;obj->queue1 = obj->queue2;obj->queue2 = temp;return top;
}// 获取栈顶元素
int myStackTop(MyStack* obj) {int size = queueSize(obj->queue1);for (int i = 0; i < size - 1; i++) {queuePush(obj->queue2, queuePop(obj->queue1));}int top = queuePeek(obj->queue1);queuePush(obj->queue2, queuePop(obj->queue1));Queue* temp = obj->queue1;obj->queue1 = obj->queue2;obj->queue2 = temp;return top;
}// 判断栈是否为空
bool myStackEmpty(MyStack* obj) {return queueEmpty(obj->queue1);
}// 释放栈内存
void myStackFree(MyStack* obj) {queueFree(obj->queue1);queueFree(obj->queue2);free(obj);
}

改进代码

单队列实现

单队列实现的关键思路：

1. 入栈 (push) 操作的实现是关键：
   • 首先将新元素添加到队列尾部
   • 然后，将该元素之前的所有元素依次出队并重新入队
   • 这样操作后，最新入栈的元素就位于队首，成为栈顶元素
2. 出栈 (pop) 和 获取栈顶元素 (top) 操作变得非常简单：
   • 出栈：直接将队首元素出队即可
   • 获取栈顶元素：直接获取队首元素

// 定义队列结构
typedef struct {int* data;int front;int rear;int size;      // 当前元素个数int capacity;
} Queue;// 创建队列
Queue* queueCreate(int capacity) {Queue* queue = (Queue*)malloc(sizeof(Queue));queue->data = (int*)malloc(sizeof(int) * capacity);queue->front = 0;queue->rear = 0;queue->size = 0;queue->capacity = capacity;return queue;
}// 入队
void queuePush(Queue* queue, int x) {if (queue->size == queue->capacity) {// 队列已满，需要扩容int newCapacity = queue->capacity * 2;int* newData = (int*)malloc(sizeof(int) * newCapacity);// 复制原有元素到新数组for (int i = 0; i < queue->size; i++) {newData[i] = queue->data[(queue->front + i) % queue->capacity];}free(queue->data);queue->data = newData;queue->front = 0;queue->rear = queue->size;queue->capacity = newCapacity;}queue->data[queue->rear] = x;queue->rear = (queue->rear + 1) % queue->capacity;queue->size++;
}// 出队
int queuePop(Queue* queue) {int val = queue->data[queue->front];queue->front = (queue->front + 1) % queue->capacity;queue->size--;return val;
}// 获取队首元素
int queuePeek(Queue* queue) {return queue->data[queue->front];
}// 判断队列是否为空
bool queueEmpty(Queue* queue) {return queue->size == 0;
}// 获取队列中元素个数
int queueSize(Queue* queue) {return queue->size;
}// 释放队列内存
void queueFree(Queue* queue) {free(queue->data);free(queue);
}// 定义栈结构（使用单个队列）
typedef struct {Queue* queue;
} MyStack;// 创建栈
MyStack* myStackCreate() {MyStack* stack = (MyStack*)malloc(sizeof(MyStack));stack->queue = queueCreate(10);  // 初始容量较小，会根据需要自动扩容return stack;
}// 入栈操作
void myStackPush(MyStack* obj, int x) {// 将元素加入队列queuePush(obj->queue, x);// 将前面的所有元素依次出队再入队，使得最新入栈的元素位于队首int size = queueSize(obj->queue);for (int i = 0; i < size - 1; i++) {queuePush(obj->queue, queuePop(obj->queue));}
}// 出栈操作
int myStackPop(MyStack* obj) {// 由于最后入栈的元素总是位于队首，直接出队即可return queuePop(obj->queue);
}// 获取栈顶元素
int myStackTop(MyStack* obj) {// 栈顶元素就是队首元素return queuePeek(obj->queue);
}// 判断栈是否为空
bool myStackEmpty(MyStack* obj) {return queueEmpty(obj->queue);
}// 释放栈内存
void myStackFree(MyStack* obj) {queueFree(obj->queue);free(obj);
}