两个栈实现队列

已于 2024-03-31 21:39:04 修改
阅读量768 收藏 10
点赞数 12
CC 4.0 BY-SA版权
文章标签： 算法
于 2024-03-31 21:33:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sysfsv/article/details/137208655

介绍

我们知道，栈和队列也属于顺序表，它们各自有着属于自己独特的性质；

用一句话总的来概括它们的性质：

栈：栈顶入栈顶出——先进先出——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;
}

测试结果：

这样我们的队列就完美的用两个栈实现出来啦!

结语：

总体来看，这道双接口的题目其实并没有那么复杂，理清楚变量和参数，这题就会变得很简单，代码虽然多，但却通俗易懂，只要多练，勤加练习，再难的题我们也能将其解决，有什么问题欢迎评论区提问哦！

评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值