【数据结构与算法】用栈实现队列
文章目录
- 😻前言
- 如何用栈实现队列？
- 用栈实现队列
- 整体的实现代码
- 😼写在最后
😻前言
😝上一章我们用队列实现了一个栈（-> 传送门 <-），而这一章就带大家用栈实现一个队列。
😜用队列实现一个栈，用的是两个队列，其出栈操作可以说是最麻烦的一步，它通过倒数据的方式最后完成出栈。而用栈实现一个队列，很明显也是需要两个栈来完成的，其出队操作其实也与倒数据的方式有关，不过两个实现方法有所不同。
🤪用队列实现栈，是通过队列的 先进先出 的性质来实现栈的 后进先出 的性质；而用栈实现队列，是通过栈的 后进先出 的性质来实现队列的 先进先出 的性质，大家别弄混淆了。
如何用栈实现队列？
-
那么如何用栈实现队列呢？肯定是需要两个栈来完成的。
-
用两个栈，每一个栈都是数据后进先出，我们仔细思考队列的先进先出这一性质，如何来操作这两个栈才能达到这样的一个性质？
-
我们可以这样操作：规定一个栈为（入数据的栈），一个栈为（出数据的栈）。一开始两个栈都为空，当我们要入队列的时候，只需要在那个入数据的栈中将数据入栈即可。当我们要出队列的时候，由于队列的性质是先进先出，这时单凭那个入数据的栈实现不了此性质的功能，因此那个出数据的栈（当前为空栈）就起作用了，具体操作为：将那个入数据的栈里面的数据依次出栈，并入入出数据的栈中，这样，最先进入入数据的栈的数据就到了出数据的栈的栈顶位置，随后在此栈出栈即可。整个过程的确实现了队列先进先出这一性质的功能，这也是最好的解决方案了 。当然，后面如果一直出队列直到出数据的栈里没有数据可出了，而此时还想执行出队列操作，那么再向入数据的栈中倒数据过来就可以了（再次执行上面的操作）。注意：无论如何，入队列的数据始终都是 入入 入数据的栈中。
- 此外，用栈实现一个队列，还需要有判空，取队头元素，队列的销毁这些功能，不过这些都是小问题，我们可以巧用轮子 （轮子就是我们提前已经实现好的栈的一系列功能） 来灵活解决这些问题。
用栈实现队列
- 这里我们直接以题目的方式来实现，题目链接：-> 传送门 <-。
题目描述：请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）
该题提供的需要我们实现的接口：
typedef struct {
} MyQueue;
MyQueue* myQueueCreate() {
}
void myQueuePush(MyQueue* obj, int x) {
}
int myQueuePop(MyQueue* obj) {
}
int myQueuePeek(MyQueue* obj) {
}
bool myQueueEmpty(MyQueue* obj) {
}
void myQueueFree(MyQueue* obj) {
}
- 由于这里我们用
C语言实现，因此需要 “造轮子”，也就是将之前实现过的栈拷贝过去。
接下来，就是对队列的一系列功能接口的实现了：
1.
-
首先当然是造轮子，有了轮子，我们对栈的一系列操作，只需要调用我们已经实现好的函数接口即可。
-
我们将之前写的栈直接拷贝过来，拷贝的代码如下：
typedef int STDataType;
typedef struct stack
{
STDataType* a;
int capacity;
int top;
}stack;
// 初始化
void STInit(stack* pt);
// 入栈
void STPush(stack* pt, STDataType x);
// 出栈
void STPop(stack* pt);
// 判空
bool STEmpty(stack* pt);
// 取栈顶元素
STDataType STTop(stack* pt);
// 栈的元素个数
int STSize(stack* pt);
// 销毁栈
void STDestroy(stack* pt);
void STInit(stack* pt)
{
assert(pt);
pt->a = NULL;
pt->capacity = 0;
pt->top = 0;
}
void STPush(stack* pt, STDataType x)
{
assert(pt);
if (pt->top == pt->capacity)
{
int newcapacity = pt->capacity == 0 ? 4 : pt->capacity * 2;
STDataType* tmp = realloc(pt->a, sizeof(STDataType) * newcapacity);
if (tmp == NULL)
{
perror("realloc fail");
exit(-1);
}
pt->a = tmp;
pt->capacity = newcapacity;
}
pt->a[pt->top++] = x;
}
void STPop(stack* pt)
{
assert(pt && !STEmpty(pt));
pt->top--;
}
bool STEmpty(stack* pt)
{
assert(pt);
return pt->top == 0;
}
STDataType STTop(stack* pt)
{
assert(pt && !STEmpty(pt));
return pt->a[pt->top - 1];
}
int STSize(stack* pt)
{
assert(pt);
return pt->top;
}
void STDestroy(stack* pt)
{
assert(pt);
free(pt->a);
pt->capacity = 0;
pt->top = 0;
}
2.
- 有了轮子之后，就是对队列的结构体的创建了，由于队列是由两个栈实现的（一个为入数据的栈，一个为出数据的栈），因此队列的结构体的成员也是两个栈：
相关代码实现：
// 匿名结构体
typedef struct {
// 入数据的栈
stack pushst;
// 出数据的栈
stack popst;
} MyQueue;
3.
- 然后是创建一个队列，就是开辟一个队列的空间，其间包含对队列里的两个栈的初始化操作。
相关代码实现：
MyQueue* myQueueCreate() {
MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
assert(obj);
// 调用栈自有的初始化函数
STInit(&obj->pushst);
STInit(&obj->popst);
return obj;
}
4.
-
接着就是对入队列操作的实现。
-
前面说过，无论如何，只需要在入数据的栈中入栈即可。
相关代码实现：
void myQueuePush(MyQueue* obj, int x) {
// 调用自己的入栈函数
STPush(&obj->pushst, x);
}
5.
-
再接着就是最复杂的出队列操作。
-
由前面的介绍，我们已经知道了思路，而现在最主要的，就是我们还需要对出数据的栈进行判空，如果出数据的栈为空，就需要在入数据的栈里倒数据过来，然后再出栈。如果不为空，直接出栈即可。
相关代码实现：
注意： 由于该函数功能与下面的返回队列开头的元素的函数功能类似，只是一个要将数据干掉，一个不干，因此，这里直接复用返回队列开头的元素的函数功能，最后只要将数据删除即可。
int myQueuePop(MyQueue* obj) {
// assert(!myQueueEmpty(obj));
// 首先判断是否是空，是否需要倒数据
// if (STEmpty(&obj->popst))
// {
// // 为空就倒数据
// while (!STEmpty(&obj->pushst))
// {
// int top = STTop(&obj->pushst);
// STPop(&obj->pushst);
// STPush(&obj->popst);
// }
// }
// int top = STTop(&obj->popst);
// STPop(&obj->popst);
// return top;
int top = myQueuePeek(obj);
// 多了一步删除操作
STPop(&obj->popst);
return top;
}
6.
-
当然还有获取队头数据的功能，也就是返回队列开头的元素。
-
在上面出队列部分已经说明思路，只是这里不需要删除那个队头数据。
相关代码实现：
int myQueuePeek(MyQueue* obj) {
assert(!myQueueEmpty(obj));
if (STEmpty(&obj->popst))
{
while (!STEmpty(&obj->pushst))
{
int top = STTop(&obj->pushst);
STPop(&obj->pushst);
STPush(&obj->popst, top);
}
}
return STTop(&obj->popst);
}
7.
-
论队列的功能怎么能少得了判空呢。
-
对于该队列的判空，我们实际上只需要判断那两个栈是否为空即可。
相关代码实现：
bool myQueueEmpty(MyQueue* obj) {
return STEmpty(&obj->pushst) && STEmpty(&obj->popst);
}
8.
-
最后就是队列的销毁了。
-
将两个栈销毁（调用自己的销毁函数），然后将队列销毁即可。
相关代码实现：
void myQueueFree(MyQueue* obj) {
// 调用自己的销毁函数
STDestroy(&obj->pushst);
STDestroy(&obj->popst);
// 销毁队列
free(obj);
}
整体的实现代码
typedef int STDataType;
typedef struct stack
{
STDataType* a;
int capacity;
int top;
}stack;
// 初始化
void STInit(stack* pt);
// 入栈
void STPush(stack* pt, STDataType x);
// 出栈
void STPop(stack* pt);
// 判空
bool STEmpty(stack* pt);
// 取栈顶元素
STDataType STTop(stack* pt);
// 栈的元素个数
int STSize(stack* pt);
// 销毁栈
void STDestroy(stack* pt);
void STInit(stack* pt)
{
assert(pt);
pt->a = NULL;
pt->capacity = 0;
pt->top = 0;
}
void STPush(stack* pt, STDataType x)
{
assert(pt);
if (pt->top == pt->capacity)
{
int newcapacity = pt->capacity == 0 ? 4 : pt->capacity * 2;
STDataType* tmp = realloc(pt->a, sizeof(STDataType) * newcapacity);
if (tmp == NULL)
{
perror("realloc fail");
exit(-1);
}
pt->a = tmp;
pt->capacity = newcapacity;
}
pt->a[pt->top++] = x;
}
void STPop(stack* pt)
{
assert(pt && !STEmpty(pt));
pt->top--;
}
bool STEmpty(stack* pt)
{
assert(pt);
return pt->top == 0;
}
STDataType STTop(stack* pt)
{
assert(pt && !STEmpty(pt));
return pt->a[pt->top - 1];
}
int STSize(stack* pt)
{
assert(pt);
return pt->top;
}
void STDestroy(stack* pt)
{
assert(pt);
free(pt->a);
pt->capacity = 0;
pt->top = 0;
}
typedef struct {
stack pushst;
stack popst;
} MyQueue;
int myQueuePeek(MyQueue* obj);
bool myQueueEmpty(MyQueue* obj);
MyQueue* myQueueCreate() {
MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
assert(obj);
STInit(&obj->pushst);
STInit(&obj->popst);
return obj;
}
v oid myQueuePush(MyQueue* obj, int x) {
STPush(&obj->pushst, x);
}
int myQueuePop(MyQueue* obj) {
// assert(!myQueueEmpty(obj));
// if (STEmpty(&obj->popst))
// {
// while (!STEmpty(&obj->pushst))
// {
// int top = STTop(&obj->pushst);
// STPop(&obj->pushst);
// STPush(&obj->popst);
// }
// }
// int top = STTop(&obj->popst);
// STPop(&obj->popst);
// return top;
int top = myQueuePeek(obj);
STPop(&obj->popst);
return top;
}
int myQueuePeek(MyQueue* obj) {
assert(!myQueueEmpty(obj));
if (STEmpty(&obj->popst))
{
while (!STEmpty(&obj->pushst))
{
int top = STTop(&obj->pushst);
STPop(&obj->pushst);
STPush(&obj->popst, top);
}
}
return STTop(&obj->popst);
}
bool myQueueEmpty(MyQueue* obj) {
return STEmpty(&obj->pushst) && STEmpty(&obj->popst);
}
void myQueueFree(MyQueue* obj) {
STDestroy(&obj->pushst);
STDestroy(&obj->popst);
free(obj);
}
😼写在最后
💝学会了用队列实现栈，也学会了用栈实现队列，回想一下，还是挺简单的，下一篇将带大家设计一个循环队列，难度会有些上升噢，大家打起精神来！！！
❤️🔥后续将会持续输出有关数据结构与算法的文章，你们的支持就是我写作的最大动力！
感谢阅读本小白的博客，错误的地方请严厉指出噢~