【栈和队列的相互转换】
目录：
- 前言
- 一、 用队列实现栈
-
- （一） 题目分析
-
- 1.队列基本操作
- 2.画图分析
- 3.翻译图解
- （二）整体代码
- 二、用栈实现队列
-
- （一） 题目分析
-
- 1.栈基本操作
- 2.画图分析
- 3.翻译图解
- （二）整体代码
- 总结
前言
打怪升级：第6天
一、 用队列实现栈
- 用队列实现栈
题目描述：
请你仅使用两个队列实现一个后入先出（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（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
（一） 题目分析
此关卡要求我们使用两个队列来实现栈的操作，第一步就是需要有队列的基本操作函数，由于C语言没有c++中的stl库可以使用，我们就需要先写出队列的基本操作。
1.队列基本操作
代码如下：
typedef int QDataType;
// 链式结构：队列节点
typedef struct QListNode
{
QDataType _data;
struct QListNode* _next;
}QNode;
// 队列的结构
typedef struct Queue
{
int len; // 记录节点的个数
QNode* _front;
QNode* _rear;
}Queue;
// 初始化队列
void QueueInit(Queue* q)
{
assert(q);
q->len = 0;
q->_front = q->_rear = NULL;
}
// 队尾入队列
void QueuePush(Queue* q, QDataType data)
{
QNode* tmp = (QNode*)malloc(sizeof(QNode));
if (tmp == NULL)
exit(-1);
tmp->_data = data;
tmp->_next = NULL;
q->len++;
if (q->_front == NULL) // 空队列
{
q->_front = q->_rear = tmp;
}
else
{
q->_rear->_next = tmp;
q->_rear = q->_rear->_next;
}
}
// 队头出队列
void QueuePop(Queue* q)
{
assert(q);
if (QueueEmpty(q))
exit(-1);
QNode* next = q->_front->_next;
free(q->_front);
q->_front = next;
if(q->_front == NULL) // 队列只剩下一个数据，删除之后rear成为野指针
q->_rear = q->_front;
q->len--;
}
// 获取队列头部元素
QDataType QueueFront(Queue* q)
{
assert(q);
if (QueueEmpty(q))
exit(-1);
return q->_front->_data;
}
// 获取队列队尾元素
QDataType QueueBack(Queue* q)
{
assert(q);
if (QueueEmpty(q))
exit(-1);
return q->_rear->_data;
}
// 获取队列中有效元素个数
int QueueSize(Queue* q)
{
assert(q);
return q->len;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
int QueueEmpty(Queue* q)
{
assert(q);
return q->len == 0;
}
// 销毁队列
void QueueDestroy(Queue* q)
{
assert(q);
QNode* cur = q->_front;
while (cur)
{
QNode* next = cur->_next;
free(cur);
cur = next;
}
}
2.画图分析
栈的特点是“后进先出”而队列的特点是“先进先出”，我们想要使用队列模拟栈就需要通过实验找出它们之间的转换关系，
如下图：
出栈操作视频解析：
用队列模拟出栈--1
用队列模拟出栈--2
另一个入栈操作：（不推荐）
3.翻译图解
题目已经明说：在执行pop和top操作时队列不为空，那么我们判不判断这个特殊情况都无所谓了，不过我还是建议大家判断一下，培养良好的做题习惯。
示例：
typedef struct {
Queue q1;
Queue q2;
} MyStack; // 栈中元素为两个队列
MyStack* myStackCreate() {
MyStack* s = (MyStack*)malloc(sizeof(MyStack));
QueueInit(&s->q1);
QueueInit(&s->q2);
return s;
}
void myStackPush(MyStack* obj, int x) { // 数据需要进到非空队列
Queue* nonemp = &obj->q1; // 我们不知道哪一个为非空队列，那就先假设是第一个
if (!QueueEmpty(&obj->q2))
nonemp = &obj->q2;
QueuePush(nonemp, x);
}
int myStackPop(MyStack* obj) {
Queue* nonemp = &obj->q1;
Queue* emp = &obj->q2;
if (!QueueEmpty(&obj->q2))
{
nonemp = &obj->q2;
emp = &obj->q1;
}
while (QueueSize(nonemp) > 1) // 非空队列中只剩一个数据时，它就是我们要删除的栈顶数据
{
QueuePush(emp, QueueFront(nonemp));
QueuePop(nonemp);
}
QDataType tmp = QueueFront(nonemp); // 记录队尾数据
QueuePop(nonemp);
return tmp;
}
int myStackTop(MyStack* obj) {
Queue* nonemp = &obj->q1;
if (!QueueEmpty(&obj->q2))
nonemp = &obj->q2;
return QueueBack(nonemp);
}
bool myStackEmpty(MyStack* obj) {
return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2); //两个队列都为空才说明栈为空
}
void myStackFree(MyStack* obj) {
QueueDestroy(&obj->q1);
QueueDestroy(&obj->q2);
free(obj);
}
（二）整体代码
示例：
#include提交结果：
补充：题目下方的进阶要求->使用一个队列模拟实现栈
提示：循环队列
二、用栈实现队列
- 用栈实现队列
题目描述：
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（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.栈基本操作
代码如下：
// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
STDataType* _a;
int _top; // 栈顶
int _capacity; // 容量
}Stack;
// 初始化栈
void StackInit(Stack* ps)
{
assert(ps);
ps->_a = (STDataType*)malloc(sizeof(STDataType) * 3);
ps->_top = 0;
ps->_capacity = 3;
}
// 入栈
void StackPush(Stack* ps, STDataType data)
{
assert(ps);
if (ps->_top == ps->_capacity)
{
STDataType* tmp = realloc(ps->_a, sizeof(STDataType) * ps->_capacity * 2);
assert(tmp);
ps->_a = tmp;
ps->_capacity *= 2;
}
ps->_a[ps->_top++] = data;
}
// 出栈
void StackPop(Stack* ps)
{
assert(ps);
if (StackEmpty(ps))
exit(-1);
ps->_top--;
}
// 获取栈顶元素
STDataType StackTop(Stack* ps)
{
assert(ps);
if (StackEmpty(ps))
exit(-1);
return ps->_a[ps->_top - 1];
}
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
assert(ps);
return ps->_top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps)
{
assert(ps);
return ps->_top == 0;
}
// 销毁栈
void StackDestroy(Stack* ps)
{
assert(ps);
free(ps->_a);
ps->_a = NULL;
ps->_top = ps->_capacity = 0;
}
2.画图分析
栈的特点是后进先出，队列的特点为先进先出，下面我们通过画图来找到它们之间的转换关系
视频解析：
用栈模拟出队--1
用栈模拟出队--2
3.翻译图解
代码如下：
typedef struct {
Stack instack;
Stack outstack;
} MyQueue; // 两个栈模拟队列，从画图我们可以看出一个栈是专门用来入数据的，另一个是用来出数据的
MyQueue* myQueueCreate() {
MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));
StackInit(&q->instack);
StackInit(&q->outstack);
return q;
}
void myQueuePush(MyQueue* obj, int x) {
StackPush(&obj->instack, x);
}
int myQueuePeek(MyQueue* obj) {
if (StackEmpty(&obj->outstack))
{
while (!StackEmpty(&obj->instack))
{
StackPush(&obj->outstack, StackTop(&obj->instack));
StackPop(&obj->instack);
}
}
return StackTop(&obj->outstack);
}
int myQueuePop(MyQueue* obj) {
STDataType con = myQueuePeek(obj);
StackPop(&obj->outstack);
return con;
}
bool myQueueEmpty(MyQueue* obj) {
return StackEmpty(&obj->instack) && StackEmpty(&obj->outstack);
}
void myQueueFree(MyQueue* obj) {
StackDestroy(&obj->instack);
StackDestroy(&obj->outstack);
free(obj);
}
（二）整体代码
示例：
// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
STDataType* _a;
int _top; // 栈顶
int _capacity; // 容量
}Stack;
// 初始化栈
void StackInit(Stack* ps)
{
assert(ps);
ps->_a = (STDataType*)malloc(sizeof(STDataType) * 3);
ps->_top = 0;
ps->_capacity = 3;
}
// 入栈
void StackPush(Stack* ps, STDataType data)
{
assert(ps);
if (ps->_top == ps->_capacity)
{
STDataType* tmp = realloc(ps->_a, sizeof(STDataType) * ps->_capacity * 2);
assert(tmp);
ps->_a = tmp;
ps->_capacity *= 2;
}
ps->_a[ps->_top++] = data;
}
// 出栈
void StackPop(Stack* ps)
{
assert(ps);
if (StackEmpty(ps))
exit(-1);
ps->_top--;
}
// 获取栈顶元素
STDataType StackTop(Stack* ps)
{
assert(ps);
if (StackEmpty(ps))
exit(-1);
return ps->_a[ps->_top - 1];
}
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
assert(ps);
return ps->_top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps)
{
assert(ps);
return ps->_top == 0;
}
// 销毁栈
void StackDestroy(Stack* ps)
{
assert(ps);
free(ps->_a);
ps->_a = NULL;
ps->_top = ps->_capacity = 0;
}
typedef struct {
Stack instack;
Stack outstack;
} MyQueue;
MyQueue* myQueueCreate() {
MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));
StackInit(&q->instack);
StackInit(&q->outstack);
return q;
}
void myQueuePush(MyQueue* obj, int x) {
StackPush(&obj->instack, x);
}
int myQueuePeek(MyQueue* obj) {
if (StackEmpty(&obj->outstack))
{
while (!StackEmpty(&obj->instack))
{
StackPush(&obj->outstack, StackTop(&obj->instack));
StackPop(&obj->instack);
}
}
return StackTop(&obj->outstack);
}
int myQueuePop(MyQueue* obj) {
STDataType con = myQueuePeek(obj);
StackPop(&obj->outstack);
return con;
}
bool myQueueEmpty(MyQueue* obj) {
return StackEmpty(&obj->instack) && StackEmpty(&obj->outstack);
}
void myQueueFree(MyQueue* obj) {
StackDestroy(&obj->instack);
StackDestroy(&obj->outstack);
free(obj);
}
提交结果：
补充：题目下方的进阶要求->实现每个操作均摊时间复杂度为 O(1) 的队列，
那么细心的朋友应该能发现有可能出现O(n)时间复杂度的地方就是计算队列的元素个数上，而我们这里使用并没有使用这些操作，这里我们其实已经达到了进阶要求。
总结
好了朋友们，以上就是栈和队列相互转换使用的例题了，我想当我们打过了这两关后我们对栈和队列的特点和用法理解都会上一个新的台阶。
如果有什么疑问或者建议都可以在评论区留言，感谢大家对
的支持。