介绍
我们知道，栈和队列也属于顺序表，它们各自有着属于自己独特的性质；
用一句话总的来概括它们的性质：
栈：栈顶入栈顶出——先进先出——First In First Out（FIFO）；
队列：队尾入队头出——先进后出——First In Last Out（FILO）;
它们的性质看似相差甚多，但在某些方面又有着一些密不可分的联系，事实上，它们可以做到相互实现——用两个栈可以实现队列，同样的，两个队列也可以实现栈。
这篇博客来向大家介绍其中的一种————两个栈实现队列
栈的完全实现
在进行队列的实现之前，我们需要把栈的所有功能全部实现，相信大家对栈的完全实现早已熟悉，如对这方面知识尚有所欠缺，还需多下功夫，由于这并不是这篇博客的重点，因此直接给出栈的实现代码，这些功能在实现队列的时候都会用到：
头文件部分：
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
typedef int SDataType;
//定义一个栈
typedef struct Stack
{
SDataType* arr;
int top;//栈顶
int capacity;
}ST;
//初始化栈
void StackInit(ST* ps);
//栈顶入数据
void StackPush(ST* ps, SDataType x);
//栈顶出数据
void StackPop(ST* ps);
//得到栈的大小;
int StackSize(ST* ps);
//得到栈顶的数据
SDataType StackTop(ST* ps);
//判断栈是否为空
bool StackEmpty(ST* ps);
//摧毁栈
void StackDestory(ST* ps);
函数定义部分：
#define _CRT_SECURE_NO_WARNINGS 1
#include "Stack.h"
void StackInit(ST* ps)
{
assert(ps);
ps->arr = NULL;
ps->capacity = ps->top = 0;
}
void StackPush(ST* ps, SDataType x)
{
assert(ps);
//先检查容量
if (ps->capacity == ps->top)
{
int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
SDataType* tmp = (SDataType*)realloc(ps->arr, newcapacity * sizeof(SDataType));
if (tmp == NULL)
{
perror("realloc");
exit(-1);
}
else
{
ps->arr = tmp;
ps->capacity = newcapacity;
}
}
ps->arr[ps->top] = x;
ps->top++;
}
void StackPop(ST* ps)
{
assert(ps);
assert(ps->top > 0);
ps->top--;
}
int StackSize(ST* ps)
{
assert(ps);
return ps->top;
}
SDataType StackTop(ST* ps)
{
assert(ps);
return ps->arr[ps->top - 1];
}
bool StackEmpty(ST* ps)
{
assert(ps);
return ps->top == 0;
}
void StackDestory(ST* ps)
{
assert(ps);
free(ps->arr);
ps->capacity = ps->top = 0;
}
MyQueue队列的实现：
上述，队列可以由两个栈组成：
因此我们需要先定义一个队列，该结构体的成员是两个栈：
typedef struct MyQueue
{
ST s1;
ST s2;
}MyQueue;
接下来进行队列的完全实现：
1.MyQueuecreate——创建一个队列
MyQueue* MyQueueCreate();
我们可以看到，这个函数的返回值是一个结构体指针类型的，但我们知道，在函数内定义结构体再返回其地址是行不通的，根据函数栈帧的创建和销毁，函数的进程结束后，其所在空间的元素都会被销毁，因此返回的地址就是一个野指针，因此，最好的办法就是malloc动态内存开辟，开辟后别忘了初始化其中的两个栈，如下：
MyQueue* MyQueueCreate()
{
MyQueue* pq = (MyQueue*)malloc(sizeof(MyQueue));
if (pq == NULL)
{
perror("malloc");
exit(-1);
}
StackInit(&pq->s1);
StackInit(&pq->s2);
return pq;
}
2.MyQueuePush——队尾插数据
void MyQueuePush(MyQueue* obj, SDataType x);
该函数实现很简单，即在不为空的栈后面尾插数据：
void MyQueuePush(MyQueue* obj, SDataType x)
{
assert(obj);
//将数据尾插到两个队列中不为空的队列，都为空就随便插一个；
if (!StackEmpty(&obj->s1))
{
StackPush(&obj->s1, x);
}
else
{
StackPush(&obj->s2, x);
}
}
3.MyQueuePop——队头删数据
SDataType MyQueuePop(MyQueue* obj);
该函数的实现相对来说就比较复杂了，由于栈只能删除栈顶的数据，也只能得到栈顶的数据，而我们现在需要的是头删数据，并返回这个头删的数据：
这里的思路方式是这样的：
队列里的两个栈，有一个为空，有一个不为空，我们要先找到不为空的栈，主要是对这个不为空的栈进行操作，因此要先判断哪个栈不为空1，并得到不为空的栈
//由于栈只能栈顶出数据，因此要将栈的前n-1个数据拷贝出来，删除第n个后再拷贝回去
//先判空
//假设
ST* empty = &obj->s1;
ST* nonempty = &obj->s2;
if (!StackEmpty(&obj->s1))
{
//s1不为空，假设错了
empty = &obj->s2;
nonempty = &obj->s1;
}
接下来，将不为空的栈的前n-1个元素拷贝到空栈中，然后删除掉第n个元素：
//将不为空的数据的前n-1个拷贝到为空的栈中，删除最后一个数据后再把所有数据重新拷贝回来
while (StackSize(nonempty) > 1)
{
StackPush(empty, StackTop(nonempty));
StackPop(nonempty);
}
SDataType ret = StackTop(nonempty);
StackPop(nonempty);
最最重要的一步来了：
栈只能取出栈顶的数据，且只能从栈顶入数据，因此把不为空的栈拷贝到为空的栈之后，原本为空的栈里对然有前n-1个元素，但其排列的顺序是与原来队列的排列顺序完全不同的，这违背了这个函数的本意，因此，我们要将empty的n-1个数据重新拷贝回去，才能得到原有的顺序：最后返回头删的数据：
//再拷贝回去
while (StackSize(empty) > 0)
{
StackPush(nonempty, StackTop(empty));
StackPop(empty);
}
return ret;
整体实现如下所示：
SDataType MyQueuePop(MyQueue* obj)
{
assert(obj);
//由于栈只能栈顶出数据，因此要将栈的前n-1个数据拷贝出来，删除第n个后再拷贝回去
//先判空
//假设
ST* empty = &obj->s1;
ST* nonempty = &obj->s2;
if (!StackEmpty(&obj->s1))
{
//s1不为空，假设错了
empty = &obj->s2;
nonempty = &obj->s1;
}
//将不为空的数据的前n-1个拷贝到为空的栈中，删除最后一个数据后再把所有数据重新拷贝回来
while (StackSize(nonempty) > 1)
{
StackPush(empty, StackTop(nonempty));
StackPop(nonempty);
}
SDataType ret = StackTop(nonempty);
StackPop(nonempty);
//再拷贝回去
while (StackSize(empty) > 0)
{
StackPush(nonempty, StackTop(empty));
StackPop(empty);
}
return ret;
}
4.MyQueuePeek——返回队头的数据
SDataType MyQueuePeek(MyQueue* obj);
这个和上个函数的实现是基本相同的，不用过多介绍，只需要强调一点，唯一不同的地方就是取到最后一个元素的时候，我们将其保存下来后要把他也继续拷贝到empty中，然后再重新把empty中的所有数据拷贝到nonempty中：
整体实现如下所示；
SDataType MyQueuePeek(MyQueue* obj)
{
assert(obj);
//返回不为空的栈的栈底的数据
//由于栈只能栈顶出数据，因此要将栈的前n-1个数据拷贝出来，返回第n个后再拷贝回去
//先判空
//假设
ST* empty = &obj->s1;
ST* nonempty = &obj->s2;
if (!StackEmpty(&obj->s1))
{
//s1不为空，假设错了
empty = &obj->s2;
nonempty = &obj->s1;
}
//将不为空的数据的前n-1个拷贝到为空的栈中，返回最后一个数据后再把所有数据重新拷贝回来
while (StackSize(nonempty) > 1)
{
StackPush(empty, StackTop(nonempty));
StackPop(nonempty);
}
SDataType ret = StackTop(nonempty);
StackPush(empty, StackTop(nonempty));
StackPop(nonempty);
//再拷贝回去
while (StackSize(empty) > 0)
{
StackPush(nonempty, StackTop(empty));
StackPop(empty);
}
return ret;
}
5.得到大小、判空、取队尾数据：
//得到队列的大小
int MyQueueSize(MyQueue* obj);
//得到队尾的数据
SDataType MyQueueBack(MyQueue* obj);
//判断队列是否为空
bool MyQueueEmpty(MyQueue* obj);
这三个函数的实现就非常简单了，直接上代码：
int MyQueueSize(MyQueue* obj)
{
assert(obj);
//返回不为空的栈的大小
if (!StackEmpty(&obj->s1))
{
return StackSize(&obj->s1);
}
else
{
return StackSize(&obj->s2);
}
}
SDataType MyQueueBack(MyQueue* obj)
{
assert(obj);
//返回不为空的栈的栈顶数据
if (!StackEmpty(&obj->s1))
{
return StackTop(&obj->s1);
}
else
{
return StackTop(&obj->s2);
}
}
bool MyQueueEmpty(MyQueue* obj)
{
assert(obj);
//两个栈都为空，队列就为空
return StackEmpty(&obj->s1) && StackEmpty(&obj->s2);
}
6.MyQueueDestory——摧毁队列：
void MyQueueDestory(MyQueue* obj);
这个函数的实现只需要记住一点，要先释放队列中的两个栈，最后释放队列：
void MyQueueDestory(MyQueue* obj)
{
assert(obj);
StackDestory(&obj->s1);
StackDestory(&obj->s2);
free(obj);
}
整体实现及其测试部分：
头文件部分：
#pragma once
#include "Stack.h"
//用两个栈来实现队列
typedef struct MyQueue
{
ST s1;
ST s2;
}MyQueue;
//创建一个初始化队列
MyQueue* MyQueueCreate();
//队尾入数据
void MyQueuePush(MyQueue* obj, SDataType x);
//队头删数据,返回删除的数据
SDataType MyQueuePop(MyQueue* obj);
//返回队头的数据
SDataType MyQueuePeek(MyQueue* obj);
//得到队列的大小
int MyQueueSize(MyQueue* obj);
//得到队尾的数据
SDataType MyQueueBack(MyQueue* obj);
//判断队列是否为空
bool MyQueueEmpty(MyQueue* obj);
//摧毁队列
void MyQueueDestory(MyQueue* obj);
函数定义部分：
#define _CRT_SECURE_NO_WARNINGS 1
#include "MyQueue.h"
MyQueue* MyQueueCreate()
{
MyQueue* pq = (MyQueue*)malloc(sizeof(MyQueue));
if (pq == NULL)
{
perror("malloc");
exit(-1);
}
StackInit(&pq->s1);
StackInit(&pq->s2);
return pq;
}
void MyQueuePush(MyQueue* obj, SDataType x)
{
assert(obj);
//将数据尾插到两个队列中不为空的队列，都为空就随便插一个；
if (!StackEmpty(&obj->s1))
{
StackPush(&obj->s1, x);
}
else
{
StackPush(&obj->s2, x);
}
}
SDataType MyQueuePop(MyQueue* obj)
{
assert(obj);
//由于栈只能栈顶出数据，因此要将栈的前n-1个数据拷贝出来，删除第n个后再拷贝回去
//先判空
//假设
ST* empty = &obj->s1;
ST* nonempty = &obj->s2;
if (!StackEmpty(&obj->s1))
{
//s1不为空，假设错了
empty = &obj->s2;
nonempty = &obj->s1;
}
//将不为空的数据的前n-1个拷贝到为空的栈中，删除最后一个数据后再把所有数据重新拷贝回来
while (StackSize(nonempty) > 1)
{
StackPush(empty, StackTop(nonempty));
StackPop(nonempty);
}
SDataType ret = StackTop(nonempty);
StackPop(nonempty);
//再拷贝回去
while (StackSize(empty) > 0)
{
StackPush(nonempty, StackTop(empty));
StackPop(empty);
}
return ret;
}
SDataType MyQueuePeek(MyQueue* obj)
{
assert(obj);
//返回不为空的栈的栈底的数据
//由于栈只能栈顶出数据，因此要将栈的前n-1个数据拷贝出来，返回第n个后再拷贝回去
//先判空
//假设
ST* empty = &obj->s1;
ST* nonempty = &obj->s2;
if (!StackEmpty(&obj->s1))
{
//s1不为空，假设错了
empty = &obj->s2;
nonempty = &obj->s1;
}
//将不为空的数据的前n-1个拷贝到为空的栈中，返回最后一个数据后再把所有数据重新拷贝回来
while (StackSize(nonempty) > 1)
{
StackPush(empty, StackTop(nonempty));
StackPop(nonempty);
}
SDataType ret = StackTop(nonempty);
StackPush(empty, StackTop(nonempty));
StackPop(nonempty);
//再拷贝回去
while (StackSize(empty) > 0)
{
StackPush(nonempty, StackTop(empty));
StackPop(empty);
}
return ret;
}
int MyQueueSize(MyQueue* obj)
{
assert(obj);
//返回不为空的栈的大小
if (!StackEmpty(&obj->s1))
{
return StackSize(&obj->s1);
}
else
{
return StackSize(&obj->s2);
}
}
SDataType MyQueueBack(MyQueue* obj)
{
assert(obj);
//返回不为空的栈的栈顶数据
if (!StackEmpty(&obj->s1))
{
return StackTop(&obj->s1);
}
else
{
return StackTop(&obj->s2);
}
}
bool MyQueueEmpty(MyQueue* obj)
{
assert(obj);
//两个栈都为空，队列就为空
return StackEmpty(&obj->s1) && StackEmpty(&obj->s2);
}
void MyQueueDestory(MyQueue* obj)
{
assert(obj);
StackDestory(&obj->s1);
StackDestory(&obj->s2);
free(obj);
}
测试部分：
#define _CRT_SECURE_NO_WARNINGS 1
#include "MyQueue.h"
int main()
{
MyQueue* obj = MyQueueCreate();
MyQueuePush(obj, 1);
MyQueuePush(obj, 2);
MyQueuePush(obj, 3);
MyQueuePush(obj, 4);
//队列只能队尾入，队头出
while (!MyQueueEmpty(obj))
{
printf("%d ", MyQueuePeek(obj));
MyQueuePop(obj);
}
printf("\n");
MyQueuePush(obj, 3);
MyQueuePush(obj, 4);
MyQueuePush(obj, 2);
MyQueuePush(obj, 1);
MyQueuePush(obj, 2);
MyQueuePush(obj, 2);
printf("size = %d\n", MyQueueSize(obj));
printf("Peek = %d\n", MyQueuePeek(obj));
MyQueuePop(obj);
MyQueuePop(obj);
MyQueuePop(obj);
printf("size = %d\n", MyQueueSize(obj));
printf("Back = %d\n", MyQueueBack(obj));
MyQueueDestory(obj);
return 0;
}
测试结果：
这样我们的队列就完美的用两个栈实现出来啦!
结语：
总体来看，这道双接口的题目其实并没有那么复杂，理清楚变量和参数，这题就会变得很简单，代码虽然多，但却通俗易懂，只要多练，勤加练习，再难的题我们也能将其解决，有什么问题欢迎评论区提问哦！
1300
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
