队列的实现与讲解

已于 2024-10-06 19:56:06 修改
阅读量249 收藏 18
点赞数 19
分类专栏： 初阶数据结构 文章标签： 数据结构 开发语言 c语言
于 2024-10-05 23:44:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_81060385/article/details/142719305
版权

一.概念与结构

1.概念

只允许在⼀端进行插⼊数据操作，在另⼀端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)

​ 入队列：进⾏插⼊操作的⼀端称为队尾

​ 出队列：进⾏删除操作的⼀端称为队头

注意：与上文讲到的栈对比，栈是先进后出，队列是先进先出。

2.结构

队列也可以数组和链表的结构实现，使⽤链表的结构实现更优⼀些，因为如果使⽤数组的结构，出队列在数组头上出数据，效率会⽐较低。

数组头删时间复杂度：O(N) ** 数组尾插时间复杂度：O(1)

单链表头删时间复杂度：O(1) 单链表尾插时间复杂度：O(N)

 因此下午队列的实现中，我们采用链表的结构来进行。

二.队列的实现

queue.h

完整头文件如下。

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
typedef int QDataType;
typedef struct QueueNode//队列节点的结构,即单链表节点的结构
{
	QDataType data;
	struct QueueNode* next;
}QNode;
typedef struct Queue//队列的结构,定义指向队列头尾的指针,以及队列节点的个数
{
	QNode* phead;
	QNode* ptail;
	QDataType size;
}Q;

void QueueInit(Q*);

//入队列,队尾
void QueuePush(Q*, QDataType);

//出队列,队头
void QueuePop(Q*);

//队列判空
bool QueueEmpty(Q*);

//取队头数据
QDataType QueueFront(Q*);

//取队尾数据
QDataType QueueBack(Q*);

//队列有效元素个数
int QueueSize(Q*);

void QueueDestroy(Q*);

分析：

1.此处我们定义了两个结构体，一个是队列的基本结构QNode，一个是用来表示队列的队头，队尾和元素个数的Q。

2.Q存在的意义主要是为了便于后续表示队列的队头，队尾时可以简化二级指针的个数，且更加清晰。

test.c

相关测试代码如下。

#define _CRT_SECURE_NO_WARNINGS 1
#include "Queue.h"
void QueueTest01()
{
	Q q;//定义队列
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	///
	printf("head:%d\n", QueueFront(&q));
	printf("tail:%d\n", QueueBack(&q));
	printf("size:%d\n", QueueSize(&q));
	QueuePop(&q);
	QueueDestroy(&q);
}

int main()
{
	QueueTest01();
	return 0;
}

队列的初始化

#define _CRT_SECURE_NO_WARNINGS 1
#include "Queue.h"
void QueueInit(Q* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

分析：

1.需注意，我们此处传入的是指针Q*而非QNode*。

2.其余置空断言操作如常。

队列的销毁

void QueueDestroy(Q* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	QNode* pcur = pq->phead;
	while (pcur)
	{
		QNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

分析：

1.由于每个节点与之前的链表类似，都是动态开辟的，因此我们通过Q*找到队列头phead，之后逐个释放节点即可。

2.依次释放之后置空并将元素个数置为0即可。

节点的创建

首先创建一个专门用来生产节点的函数，避免后续插入时代码的冗余。

QNode* BuyNode(QDataType x)
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

注意：在创建节点后记得把size++。

队尾插入数据——入队列

void QueuePush(Q* pq, QDataType x)
{
	assert(pq);
	if (pq->phead == NULL)
		pq->phead = pq->ptail = BuyNode(x);
	else
	{
		pq->ptail->next = BuyNode(x);
		pq->ptail = pq->ptail->next;
	}
	pq->size++;
}

分析：与链表的尾插原理基本相同。

队列判空

在进入删除之前，首先需要判断队列数据个数是否为空。

bool QueueEmpty(Q* pq)
{
	assert(pq);
	return pq->phead == NULL && pq->ptail == NULL;
}

此处通过使用size个数是否为0进行判空也可。

队头删除数据——出队列

void QueuePop(Q* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	//只有一个节点的情况,避免ptail变成野指针
	if (pq->ptail == pq->phead)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else
	{
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}
	pq->size--;
}

分析：

1.首先判断队列数据是否为空。

2.之后考虑两种情况，如果队列只有一个节点，那么直接删除之后需要将队头和队尾都置为空。

3，如果队列不止存在一个节点，同链表的删除原理类似。

返回队头数据

QDataType QueueFront(Q* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->phead->data;
}

返回队尾数据

QDataType QueueBack(Q* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->ptail->data;
}

输出队列数据个数

int QueueSize(Q* pq)
{
	assert(pq);

	//不规范且时间复杂度O(n)
	//int size = 0;
	//QNode* pcur = pq->phead;
	//while (pcur)
	//{
	//	size++;
	//	pcur = pcur->next;
	//}
	//return size;


	return pq->size;

}

分析：

1.如果我们不在最初引入变量size记录数据个数，由于队列是链表结构无法直接通过下标访问元素个数，需要逐个遍历记录，时间复杂度为O（n）。

2.直接返回size的话就可以减少时间消耗。

三.完整代码

#define _CRT_SECURE_NO_WARNINGS 1
#include "Queue.h"
void QueueInit(Q* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}


QNode* BuyNode(QDataType x)
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}


void QueuePush(Q* pq, QDataType x)
{
	assert(pq);
	if (pq->phead == NULL)
		pq->phead = pq->ptail = BuyNode(x);
	else
	{
		pq->ptail->next = BuyNode(x);
		pq->ptail = pq->ptail->next;
	}
	pq->size++;
}



bool QueueEmpty(Q* pq)
{
	assert(pq);
	return pq->phead == NULL && pq->ptail == NULL;
}
void QueuePop(Q* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	//只有一个节点的情况,避免ptail变成野指针
	if (pq->ptail == pq->phead)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else
	{
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}
	pq->size--;
}



QDataType QueueFront(Q* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->phead->data;
}


QDataType QueueBack(Q* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->ptail->data;
}


int QueueSize(Q* pq)
{
	assert(pq);

	//不规范且时间复杂度O(n)
	//int size = 0;
	//QNode* pcur = pq->phead;
	//while (pcur)
	//{
	//	size++;
	//	pcur = pcur->next;
	//}
	//return size;


	return pq->size;

}



void QueueDestroy(Q* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	QNode* pcur = pq->phead;
	while (pcur)
	{
		QNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

以上就是关于队列的概念，结构和用链表方式实现队列的讲解，欢迎各位大佬前来支持斧正！！！

诚丞成
关注
专栏目录
消息队列 原理与代码实例讲解
AI天才研究院
06-09 1053
消息队列 原理与代码实例讲解 1. 背景介绍 1.1 消息队列概述 消息队列(Message Queue)，简称MQ，是一种在分布式系统中广泛使用的异步通信机制。它充当消息的中间件，允许发送方将消息发送到队列中，接收方从队列中获取消息并进行处理。
第六章 队列的讲解与实现
Turing_Sheep的博客
11-10 649
在上一章节中，我们了解到栈这种数据结构的特点是先进后出，那么今天所讲解的队列的特点则恰恰与之相反。队列这种数据结构的特点是：先进先出，后进后出。接下来我们将对其进行详细地讲解。
队列实现栈
adcxhw的博客
05-20 1127
队列实现栈，多理解几遍，多些几遍也就会了。
用队列实现栈
shylyly_的博客
07-17 930
用队列实现栈 的详细讲解和实现
队列原理与实例讲解
一颗西柚的博客
04-15 1232
队列 队列是一个有序列表, 可以用数组或者链表来实现 遵循先入先出的原则,即: 先存入队列的数据, 要先取出, 后存入的数据要后取出. 数组模拟队列 队列本身是有序列表, 若使用数组的结构 来存储队列的数据, 则队列数组的声明如下图: 其中 maxSize是该队列的最大容量 因为队列的输出, 输入分别从前后端来处理,因此需要两个变量front 及rear分别记录队列前后端的下标, front会随着数据输出而改变, 而rear则是随着数据输入而改变 当我们将数组存入队列时称为"addQ
springboot kafka 实现延时队列
热门推荐
qq_41889508的博客
04-21 5万+
延时队列的技术实现方案有：redis延时队列，Kafka延时队列，rabbit延时队列，Kafka延时队列等 本文章springboot kafka 实现延时队列，使用Kafka消费者的pause函数（暂停）和resume函数（恢复）+定时任务+事件监听机制+工厂。 延时任务的应用场景： 1，订单超时自动取消：用户下单后，如果在指定时间（半小时）内超时未完成支付，系统会自动取消订单，释放库存。 2，定时推送：比如消息通知，用户预约某个服务，系统会在服务开始前一定时间发送提醒短信。 3，定时任务 4，限时抢购
队列的实现
weixin_70238476的博客
06-18 1186
队列实现详解
单调队列的实现
wyuchen123的博客
09-14 1379
这是C++算法基础-数据结构专栏的第二十五篇文章，详细讲解了单调队列的定义、过程、性质、代码实现等内容。
数据结构——用队列实现栈
2302_76408569的博客
08-07 787
本文详细讲解了基于C语言用队列实现栈
实现一个阻塞队列
jakelihua
01-30 1094
阻塞队列是一种特殊类型的队列，具有阻塞特性。当队列为空时，消费者线程试图从队列中获取元素时会被阻塞，直到队列中有新的元素加入；当队列已满时，生产者线程试图向队列中添加元素时会被阻塞，直到队列中有空位。
优先队列讲解及代码实现.zip
04-12
优先队列 优先队列（Priority Queue）是一种数据结构，它类似于常规的队列或栈，但每个元素都有与其关联的“优先级”。在优先队列中，元素的出队顺序是基于...下面是一个简单的基于数组和插入排序的优先队列实现示例：
多级反馈队列调度算法讲解.pdf
05-19
6. **可变参数**：实际实现中，队列的数量、优先级的划分、时间片的长度以及反馈策略都可以根据具体应用和系统资源情况进行调整。例如，某些系统可能会更重视实时性，将更多的队列设置为高优先级，而其他系统可能更...
AJAX请求队列实现
10-21
AJAX请求队列实现主要讲解了如何管理多个异步AJAX请求，确保它们能够按照一定的顺序执行，以防止请求因执行时机冲突而被取消或丢失。在Web应用中，用户可能会在短时间内发起多个请求，这些请求可能是异步的。如果不...
微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单
11-10
【微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单】这篇文章主要讲解了如何在微服务架构中使用SpringBoot整合Redis来构建一个基于Redis Stream的消息队列，以此来实现实时、高效的异步秒杀...
数据结构编程实践20讲(Python版)—05二叉树
最新发布
AnFany
10-08 400
数据结构编程实践20讲(Python版)-05二叉树
数据结构-哈西表笔记
2302_80490510的博客
10-05 322
如果不用去重就可以用哈希表。
数据结构 ——— 单链表oj题：返回链表的中间节点
weixin_55341642的博客
10-02 411
slow 指针一次走一步，fast 指针一次走两步，那么 fast 指针就是 slow 指针的二倍
网站建设中常见的网站后台开发语言有哪几种，各自优缺点都是什么？
2301_80154636的博客
09-24 2322
总的来说，每种语言都有其特定的优势和局限，选择哪种语言取决于项目需求、团队技能和预期的维护成本等多种因素。理解这些语言的核心特性和适用场景可以帮助开发者做出更明智的选择，从而有效提升项目的成功率和开发效率。这些语言各有其独特的优缺点，适用于不同的开发场景和需求。市场上常见的网站后台开发语言有。
蝶形激光器驱动(温控精度0.002°C 激光电流分辨率5uA)
洛溪之恋的博客
10-01 410
蝶形半导体激光器驱动电流的稳定性直接决定了其输出波长的稳定性,进而影响检测精度.为了满足气体浓度检测中对激光器输出波长稳定可调的要求,设计了数字与模拟电路混合的恒流驱动电路.STM32为主控芯片数控模块完成扫描AD/DA转换;模拟电路主要由负反馈运算放大、高精度CMOS管和反馈电阻构成,完成电压到电流的转换,输出至蝶形半导体激光器,实现蝶形半导体激光器恒流驱动.输出电流在0～300 mA范围内连续可调,输出驱动电流误差小于 ±0.003 mA,满足系统对恒流驱动 ±0.005 mA的误差精度要求。
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值