【数据结构初阶】详解：实现循环队列、用栈实现队列、用队列实现栈

于 2024-08-02 09:58:01 发布
阅读量962 收藏 10
点赞数 32
文章标签： 数据结构 java c语言 开发语言 青少年编程 汇编 android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79531041/article/details/140671514
版权

文章目录

一、循环队列

1、题目简述

与队列的区别：循环队列的空间大小是固定的，且队尾连接队头形成循环。
在这里插入图片描述
要实现的方法：
在这里插入图片描述

2、方法讲解

我们开始就说过，循环队列的数据储存的数量是固定的，为了方便讲解，我们这里设队列可储存4个数据。即 k=4。

2.1、了解tail的指向

我们将队列的数据存放在数组中，head为队头下标，tail为队尾的下一个元素的下标。
在这里插入图片描述

tail为队尾的下一个元素的下标 原因：
若指向队尾数据：
当对列为空时，head、tail均指向首，即head=tail=0
而当队列有一个元素时，tail指向队尾，则仍有head=tail=0
产生歧义，无法区分队列是否有元素。
故，tail必须指向队尾元素的下一个元素

2.2、了解空间是如何利用的

注：队列遵循先进先出的规则
下面来举例了解数据的循环入队列：
1、入三个数据1,2，3
在这里插入图片描述

2、出两次数据
在这里插入图片描述
3、入三个数据4，5，6
在这里插入图片描述
在有限空间内，保证先进先出，空间重复使用。
那么问题来了：如何判断队列是否为空？

2.3、如何判断队列是否为空（假溢出问题）？

假溢出：空、满时判断条件相同。
在这里插入图片描述
此时无法区分空、满。
为了解决假溢出问题，我们有两种方法

  • 方法一：通过size来计录数据
    空：size = 0
    满：size = k (k:队列可储存数据个数)

  • 方法二：多开一个空间
    k = 4 (最多push入4个数据)
    在这里插入图片描述
    push入4个数据 1，2，3，4
    在这里插入图片描述
    空一个空间出来，则满的时候 head不可能等于tail，假溢出问题就解决了。
    已经入了4个数据了，想要再入数据就要先出数据，把空间空出来。

pop 出三次
在这里插入图片描述
push 入 5,6，7
在这里插入图片描述
由上可得：

空： head == tail
满： （tail+1）% （k+1）== head

2.4、实现代码

1、初始化
在这里插入图片描述
2、获取队首元素
在这里插入图片描述
3、取尾
在这里插入图片描述
在取尾返回时，也可写为
在这里插入图片描述

//数组
typedef struct {
    int* a;
    //数组下标
    int head;
    int tail;//指向尾的下一个
    int k;
} MyCircularQueue;

//初始化
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    //开k+1个数组空间
    obj->a = (int*)malloc(sizeof(int) * (k + 1));
    obj->head = obj->tail = 0;
    obj->k = k;
    return obj;
}
//判空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->head == obj->tail;
}
//判满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->tail + 1) % (obj->k + 1) == obj->head;
}
//入队列
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (myCircularQueueIsFull(obj))
        return false;

    obj->a[obj->tail] = value;
    obj->tail++;
    obj->tail %= (obj->k + 1);
    return true;
}
//删除数据
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
        return false;
    obj->head++;
    obj->head %= obj->k + 1;
    return true;
}
//找头
int myCircularQueueFront(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
        return -1;
    else
        return obj->a[obj->head];
}
//取尾
int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
        return -1;
    else
        return obj->tail==0? obj->a[obj->k] : obj->a[obj->tail-1];
}

//释放
void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

二、用栈实现队列

1、题目简述

在这里插入图片描述
注意：C语言不支持栈，我们需要先模拟栈。
模拟栈在这里就不赘述了，以下是C语言模拟的栈：

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;//指针指向数组
	int top;
	int capacity;//数组大小
}ST;

//初始化与销毁
void STInit(ST* pst)
{
	assert(pst);//指针不为空
	pst->a = NULL;

	//若初始化top=0；++之后，当要入栈的数据入完，top指向的是栈顶元素的下一个位置（因为top进行了++）
	//若初始化top=-1；++之后，当要入栈的数据入完，top指向的是栈顶元素
	pst->top = 0;
	pst->capacity = 0;
}
void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}

//入栈、出栈
void STPush(ST* pst, STDataType x)
{
	assert(pst);

	//扩容
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
        STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity*sizeof(STDataType));
		//扩容是否成功
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;

	}
	//入栈：给数组（栈）放入值之后，top++
	pst->a[pst->top] = x;//数组a中的元素为x
	pst->top++;
	//若初始化top=0；++之后，当要入栈的数据入完，top指向的是栈顶元素的下一个位置（因为top进行了++）
	//若初始化top=-1；++之后，当要入栈的数据入完，top指向的是栈顶元素

}
void STPop(ST* pst)//出栈：删除数据
{
	assert(pst);
	assert(pst->top > 0);//栈不为空
	pst->top--;
}

//取栈顶数据
STDataType STTop(ST* pst)
{
	assert(pst);

	return pst->a[pst->top - 1];
	//若初始化top=0；++之后，当要入栈的数据入完，top指向的是栈顶元素的下一个位置（因为top进行了++）
	//所以栈顶元素是pst->top-1
}

//判空
bool STEmpty(ST* pst)
{
	assert(pst);

	return pst->top == 0;//top为0，即为空，返回1
	//不为空，返回0
}

//获取数据个数
int STSize(ST* pst)
{
	assert(pst);
	return pst->top;
}

2、方法讲解

  • 栈：从栈顶入、从栈顶出。满足先进后出。

       一种入栈顺序，可有多种（边进边出）出栈顺序

  • 队列：从队尾入、从队头出。满足先进先出。

    一种入队顺序，只有一种出队顺序。

使用两个栈，一个只入数据，一个只出数据。要用栈来实现队列的顺序特点。

2.1、讲解

在这里插入图片描述
1、入数据1,2，3,4
在这里插入图片描述
2、出数据
如果popst内的数据为空，就将pushst内的数据导入popst中，此时从popst中按栈的顺序出数据时，所出顺序即为队列的出数据顺序。
在这里插入图片描述
入的数据与出的数据的顺序相同，符合队列先进先出的逻辑。

2.2、实现代码

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;//指针指向数组
	int top;
	int capacity;//数组大小
}ST;

//初始化与销毁
void STInit(ST* pst)
{
	assert(pst);//指针不为空
	pst->a = NULL;

	//若初始化top=0；++之后，当要入栈的数据入完，top指向的是栈顶元素的下一个位置（因为top进行了++）
	//若初始化top=-1；++之后，当要入栈的数据入完，top指向的是栈顶元素
	pst->top = 0;
	pst->capacity = 0;
}
void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}

//入栈、出栈
void STPush(ST* pst, STDataType x)
{
	assert(pst);

	//扩容
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
        STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity*sizeof(STDataType));
		//扩容是否成功
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;

	}
	//入栈：给数组（栈）放入值之后，top++
	pst->a[pst->top] = x;//数组a中的元素为x
	pst->top++;
	//若初始化top=0；++之后，当要入栈的数据入完，top指向的是栈顶元素的下一个位置（因为top进行了++）
	//若初始化top=-1；++之后，当要入栈的数据入完，top指向的是栈顶元素

}
void STPop(ST* pst)//出栈：删除数据
{
	assert(pst);
	assert(pst->top > 0);//栈不为空
	pst->top--;
}

//取栈顶数据
STDataType STTop(ST* pst)
{
	assert(pst);

	return pst->a[pst->top - 1];
	//若初始化top=0；++之后，当要入栈的数据入完，top指向的是栈顶元素的下一个位置（因为top进行了++）
	//所以栈顶元素是pst->top-1
}

//判空
bool STEmpty(ST* pst)
{
	assert(pst);

	return pst->top == 0;//top为0，即为空，返回1
	//不为空，返回0
}

//获取数据个数
int STSize(ST* pst)
{
	assert(pst);
	return pst->top;
}
//两个栈实现队列
typedef struct {
	ST pushst; //入数据
	ST popst;  //出数据
} MyQueue;


MyQueue* myQueueCreate() {
	MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
	STInit(&obj->pushst);
	STInit(&obj->popst);
	return obj;
}
//入队
void myQueuePush(MyQueue* obj, int x) {
	STPush(&obj->pushst,x);
}
//出队
int myQueuePop(MyQueue* obj) {
	int front = myQueuePeek(obj); //队头
    STPop(&obj->popst);
    return front;
}
//找队头
int myQueuePeek(MyQueue* obj) {
	//如果popst为空，就倒数据，倒完的popst的顺序为先进先出
    if(STEmpty(&obj->popst))
    {
        //倒数据
        while(!STEmpty(&obj->pushst))
        {
            int top = STTop(&obj->pushst);
            STPush(&obj->popst,top);
            STPop(&obj->pushst);
        }
    }
    return STTop(&obj->popst);
}

bool myQueueEmpty(MyQueue* obj) {
	return STEmpty(&obj->popst) && STEmpty(&obj->pushst);
}

void myQueueFree(MyQueue* obj) {
	STDestroy(&obj->popst);
	STDestroy(&obj->pushst);
	free(obj);
}

三、用队列实现栈

1、题目简述

在这里插入图片描述
C语言模拟的队列：

typedef int QDataType;
typedef struct QueueNode
{
	QDataType val;
	struct QueueNode* next;
}QNode;

typedef struct Queue//可避免使用二级指针和传多个参数
{
	int size;//size为每个节点的编号，每增加一个，size++
	QNode* phead;
	QNode* ptail;
}Queue;
//初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->size = 0;
	pq->phead = NULL;
	pq->ptail = NULL;
}

//销毁
void QueueDestroy(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

//队尾插入
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc error");
		return;
	}
	newnode->next = NULL;
	newnode->val = x;
	if (pq->phead == NULL)//原队列无节点
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}

//队头删除
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->size != 0);
	//只有一个
	if (pq->phead->next == NULL)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;

	}
	//多个节点
	else
	{
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;

	}
	pq->size--;
}

//找头数据
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	//assert(pq->phead);
	return pq->phead->val;
}

//找尾数据
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail);
	return pq->ptail->val;
}

//判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}
//统计个数
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}

2、方法讲解

在这里插入图片描述

2.1、讲解

1、入栈 1,2，3,4
判断哪一个队列为空，入到为空的队列中
在这里插入图片描述
2、删除栈顶数据
将不为空的队列中的队尾数据之前的所有数据导入为空的队列中，而原队列中只剩下要删除的元素。
在这里插入图片描述

//删除栈顶元素
int myStackPop(MyStack* obj) {
	//将该队列队尾之前的元素（size-1）push到空的队列中
	//原队列中只剩下要删除的元素
	Queue* empty = &obj->q1;
	Queue* nonEmpty = &obj->q2;
	if (!QueueEmpty(&obj->q1))
	{
		empty = &obj->q2;
		nonEmpty = &obj->q1;
	}
	while (QueueSize(nonEmpty) > 1)
	{
		QueuePush(empty, QueueFront(nonEmpty));
		QueuePop(nonEmpty);
	}
	int top = QueueFront(nonEmpty);
	QueuePop(nonEmpty);
	return top;
}

2.2、实现代码

//两个队列实现栈（后进先出）
typedef int QDataType;
typedef struct QueueNode
{
	QDataType val;
	struct QueueNode* next;
}QNode;

typedef struct Queue//可避免使用二级指针和传多个参数
{
	int size;//size为每个节点的编号，每增加一个，size++
	QNode* phead;
	QNode* ptail;
}Queue;
//初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->size = 0;
	pq->phead = NULL;
	pq->ptail = NULL;
}

//销毁
void QueueDestroy(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

//队尾插入
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc error");
		return;
	}
	newnode->next = NULL;
	newnode->val = x;
	if (pq->phead == NULL)//原队列无节点
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}

//队头删除
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->size != 0);
	//只有一个
	if (pq->phead->next == NULL)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;

	}
	//多个节点
	else
	{
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;

	}
	pq->size--;
}

//找头数据
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	//assert(pq->phead);
	return pq->phead->val;
}

//找尾数据
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail);
	return pq->ptail->val;
}

//判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}
//统计个数
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}

typedef struct {//匿名结构体
	Queue q1;
	Queue q2; //两个队列
} MyStack;

//初始化
MyStack* myStackCreate() {
	MyStack* obj = (MyStack*)malloc(sizeof(MyStack));//malloc开辟的空间在出函数后不会销毁
	QueueInit(&obj->q1);
	QueueInit(&obj->q2);//优先级->高于&
	return obj;
}
//入栈
void myStackPush(MyStack* obj, int x) {
	//push到不为空的队列中
	if (!QueueEmpty(&obj->q1))
	{
		QueuePush(&obj->q1, x);
	}
    else
    {
        QueuePush(&obj->q2, x);
    }
	
}
//删除栈顶元素
int myStackPop(MyStack* obj) {
	//将该队列队尾之前的元素（size-1）push到空的队列中
	//原队列中只剩下要删除的元素
	Queue* empty = &obj->q1;
	Queue* nonEmpty = &obj->q2;
	if (!QueueEmpty(&obj->q1))
	{
		empty = &obj->q2;
		nonEmpty = &obj->q1;
	}
	while (QueueSize(nonEmpty) > 1)
	{
		QueuePush(empty, QueueFront(nonEmpty));
		QueuePop(nonEmpty);
	}
	int top = QueueFront(nonEmpty);
	QueuePop(nonEmpty);
	return top;
}
//找栈顶元素
int myStackTop(MyStack* obj) {
	//找不为空的队尾数据
	if (!QueueEmpty(&obj->q1))
	{
		return QueueBack(&obj->q1);
	}
	else
	{
		return QueueBack(&obj->q2);
	}
}

bool myStackEmpty(MyStack* obj) {

	return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
	QueueDestroy(&obj->q1);
	QueueDestroy(&obj->q2);
	free(obj);
}

四、谢谢观看

jyan_敬言
关注
  • 32
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
循环队列的实现
qq_58330935的博客
11-29 1041
用顺序表实现循环队列
链队列在队头插入元素c语言,数据结构实验5_C语言_链队列的基本操作、入队、出队、获取队头元...
weixin_29224589的博客
05-25 2133
数据结构实验5_C语言_链队列的基本操作、入队、出队、获取队头元数据结构实验5_C语言_链队列的基本操作、入队、出队、获取队头元素等实验5、链队列的基本操作(1)实验目的通过该实验，使学生理解链队列的构造特点并灵活应用，掌握链队基本操作的编程实现，认识栈是在一端进行插入，在另一端进行删除集中操作的线性结构，掌握队列的“先入先出”操作特点，知道判断队列空和满的条件，进一步熟悉C语言中指针操作。(2)...
循环队列实现
historycomputer的博客
09-22 920
循环队列数组法实现。
【数据结构与算法】详解 “清华大学（考研）OJ题(1)
最新发布
2401_84181340的博客
04-27 866
✨综上：就是层序遍历啦~➡️相信大家对新的遍历方式有不一样的看法了吧🧡。
linux公共基础-初阶
HEIKENZ的博客
11-08 2293
Linux Public Basics公共基础 备注1：20161108 15:54，系统学习过之后上述列出的内容就不再显得生疏。建议先了解目录树和 Linux文件系统层次化标准（Linux FileSystem Hierarchy Standard（FHS）），然后再系统学习相应系统操作命令（关于应用服务的搭建可以在学习基础操作命令后就开始）。（个人是先学习少数常用系统基础的操作命令，然后
Android面试必问的Activity，初阶，中高阶问法，你都掌握了吗？（要求熟读并背诵全文）
chuhe1989的博客
11-20 1525
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cXs1wGDx-1605843173409)(https://upload-images.jianshu.io/upload_images/24142630-84668ed4a42819ee.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)] Activity是我们常用App开发中最重要的组件，主要用于展示界面和用户交互。本文分为三个部分： Activity源码和常见
详解后端工程师必看学习路线图（含初、中、高阶）
zf888999666的博客
08-23 1905
设计模式：网关模式，Gateway、边车模式，Sidecar、服务网格，Service Mesh、防腐层，Anti-corruption Layer、分布式锁、配置中心、异步通讯、幂等性。工程：监控追踪、服务/资源调度、流量控制、数据调度、开发与运维自动化、负载均衡+健康检查、服务发现+动态路由+健康检查、自动化运维。弹性（容错）设计：服务降级、服务限流、熔断设计、补偿事务、隔离设计、异步通讯、幂等性设计、重试设计、bulkhead。算法与数据结构：性能分析、基本数据结构（列表、树等）、排序、查找、图。
CRM初阶详解：从概念到未来
“CRM初阶的全面概述.docx” 在当今商业环境中，CRM（Customer Relationship Management，客户关系管理）已经成为企业提升效率和优化客户体验的重要工具。这篇文档详细介绍了CRM的基础知识，适合初学者理解。 首先...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值