数据结构基础-队列

已于 2023-10-01 21:21:36 修改
阅读量74 收藏
点赞数
分类专栏： C++ 文章标签： 数据结构 c++
于 2023-10-01 19:51:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41729472/article/details/133467586
版权

队列是一种受限的线性表，(Queue)，它是一种运算受限的线性表,先进先出(FIFO First In First Out)。

它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。

顺序存储

定义结构

#define MaxSize 5
typedef int DataType;
typedef struct Queue {
	DataType queue[MaxSize];
	int front;
	int rear;
}SeqQueue;

初始化

void initQueue(SeqQueue* SQ) {
	if (!SQ) return;
	SQ->front = SQ->rear = 0;
}

判断队空或队满

int isEmpty(SeqQueue* SQ) {
	if (!SQ) return 0;
	if (SQ->front == SQ->rear) return 1;
	return 0;
}

int isFull(SeqQueue* SQ) {
	if (!SQ) return 0;
	if (SQ->rear == MaxSize) return 1;
	return 0;
}

入队

bool enterQueue(SeqQueue* SQ, DataType val) {
	if (!SQ) return false;
	if (isFull(SQ)) {
		cout << "Queue is full, can't enter !" << endl;
		return false;
	}
	SQ->queue[SQ->rear] = val;
	SQ->rear++;
	return true;
}

出队

bool outQueue(SeqQueue* SQ, DataType& val) {
	if (!SQ || isEmpty(SQ)) {
		cout << "Queue is empty" << endl;
		return false;
	}
	val = SQ->queue[SQ->front];
	for (int i = SQ->front + 1; i < SQ->rear; i++) {
		SQ->queue[i - 1] = SQ->queue[i];
	}
	SQ->rear--;
	return true;
}

bool outQueue2(SeqQueue* SQ, DataType& val) {
	if (!SQ || isEmpty(SQ)) {
		cout << "Queue is empty" << endl;
		return false;
	}
	if (SQ->front >= MaxSize) {
		cout << "Qqueue is out of range" << endl;
		return false;
	}
	val = SQ->queue[SQ->front];
	SQ->front++;
	return true;
}

输出队

void printQueue(SeqQueue* SQ) {
	if (!SQ) return;
	int i = SQ->front;
	for (; i < SQ->rear; i++) {
		cout << setw(4) << SQ->queue[i];

	}
	cout << endl;
}

获取首元素

int getHead(SeqQueue* SQ) {
	if (!SQ || isEmpty(SQ)) {
		cout << "Queue is empty" << endl;
		return;
	}
	return SQ->queue[SQ->front];
}

清空队列

void clearQueue(SeqQueue* SQ) {
	if (!SQ) return;
	SQ->front = SQ->rear = 0;
}

队列长度

int getLength(SeqQueue* SQ) {
	if (!SQ) return 0;
	return SQ->rear - SQ->front;
}

测试

int main() {
	SeqQueue* SQ = new SeqQueue;
	DataType data = -1;
	//初始化队列
	initQueue(SQ);
	//入队
	for (int i = 0; i < 7; i++) {
		enterQueue(SQ, i);
	}
	//打印队列中的元素
	printf("队列中的元素(总共%d 个)：", getLength(SQ));
	printQueue(SQ);
	cout << endl;
	//出队
	if (outQueue2(SQ, data)) {
		cout << "出队的元素是：" << data << endl;
	}
	else {
		cout << "出队失败！" << endl;
	}
	//打印队列中的元素
	printf("出队一个元素后，队列中剩下的元素：");
	printQueue(SQ);
	cout << endl;
	return 0;
}

链式存储

结构定义

#define MaxSise 5
typedef int DataType;
typedef struct _QNode {
	DataType data;
	struct _QNode* next;
}QNode;
typedef QNode* QNodePtr;
typedef struct Queue {
	int length;
	QNodePtr front;
	QNodePtr rear;
}LinkQueue;

初始化

void initQueue(LinkQueue* LQ) {
	if (!LQ) return;
	LQ->length = 0;
	LQ->front = LQ->rear = NULL;
}

判断队空或队满

bool isEmpty(LinkQueue* LQ) {
	if (!LQ) return false;
	return LQ->front == NULL;
}

bool isFull(LinkQueue* LQ) {
	if (!LQ) return false;
	return LQ->length == MaxSise;
}

入队

bool enterQueue(LinkQueue* LQ, DataType data) {
	if (!LQ || isFull(LQ)) {
		cout << "Queue is full, can't enter !" << endl;
		return false;
	}
	QNode* qNode = new QNode;
	qNode->data = data;
	qNode->next = NULL;
	if (isEmpty(LQ)) {
		LQ->front = LQ->rear = qNode;
	}
	else {
		LQ->rear->next = qNode;
		LQ->rear = qNode;
	}
	LQ->length++;
	return true;
}

出队

bool outQueue(LinkQueue* LQ, DataType& data) {
	if (!LQ || isEmpty(LQ)) {
		cout << "Queue is empty !" << endl;
		return false;
	}
	QNode* tmp = LQ->front;
	data = tmp->data;
	LQ->front = tmp->next;
	if (!(LQ->front)) LQ->rear = NULL;//如果对头出列后不存在其他元素，则rear节点也要置空
	LQ->length--;
	delete tmp;
	return true;
}

输出队

void printQueue(LinkQueue* LQ) {
	if (!LQ) return;
	if (isEmpty(LQ)) {
		cout << "Queue is empty !" << endl;
		return;
	}
	QNodePtr tmp;
	tmp = LQ->front;
	while (tmp) {
		cout << setw(4) << tmp->data;
		tmp = tmp->next;
	}
	cout << endl;
}

获取首元素

void getHead(LinkQueue* LQ,DataType &data) {
	if (!LQ || isEmpty(LQ)) {
		cout << "Queue is empty !" << endl;
		return;
	}
	data = LQ->front->data;
}

清空队列

void clearQueue(LinkQueue* LQ) {
	if (!LQ) return;
	QNodePtr tmp;
	
	while (LQ->front) {
		tmp = LQ->front->next;
		delete LQ->front;
		LQ->front = tmp;
	}
	LQ->front = LQ->rear = NULL;
	LQ->length = 0;
}

队列长度

int getLength(LinkQueue* LQ) {
	if (!LQ) return 0;
	return LQ->length;
}

测试

int main() {
	LinkQueue* LQ = new LinkQueue;
	DataType data = -1;
	//初始化队列
	initQueue(LQ);
	//入队
	for (int i = 0; i < 7; i++) {
		enterQueue(LQ, i);
	}
	//打印队列中的元素
	printf("队列中的元素(总共%d 个)：", getLength(LQ));
	printQueue(LQ);
	cout << endl;
	//出队
	
	if (outQueue(LQ, data)) {
		cout << "出队的元素是：" << data << endl;
	}
	else {
		cout << "出队失败！" << endl;
	}
	
	//打印队列中的元素
	printf("出队一个元素后，队列中剩下的元素[%d]：", getLength(LQ));
	printQueue(LQ);
	cout << endl;
	clearQueue(LQ);
	cout << "清空队列!\n";
	printQueue(LQ);
	//清理资源
	delete LQ;
	return 0;
}

循环队列

结构定义

#define MaxSize 5
typedef int DataType;
typedef struct Queue {
	DataType queue[MaxSize];
	int front;
	int rear;
}SeqQueue;

初始化

void initQueue(SeqQueue* SQ) {
	if (!SQ) return;
	SQ->front = SQ->rear = 0;
}

判断队空或队满

bool isEmpty(SeqQueue* SQ) {
	if (!SQ) return false;
	return SQ->front == SQ->rear;
}

bool isFull(SeqQueue* SQ) {
	if (!SQ) return false;
	return ((SQ->rear + 1) % MaxSize) == SQ->front;
}

入队

bool enterQueue(SeqQueue* SQ, DataType data) {
	if (!SQ) return false;
	if (isFull(SQ)) {
		cout << "Queue is out!" << endl;
		return false;
	}
	SQ->queue[SQ->rear] = data;
	SQ->rear = (SQ->rear + 1) % MaxSize;
	return true;
}

出队

bool outQueue(SeqQueue* SQ, DataType& data) {
	if (!SQ || isEmpty(SQ)) {
		cout << "Queue is empty" << endl;
		return false;
	}
	data = SQ->queue[SQ->front];
	SQ->front = (SQ->front + 1) % MaxSize;
	return true;
}

输出队

void printQueue(SeqQueue* SQ) {
	if (!SQ) return;
	int i = SQ->front;
	while (i != SQ->rear) {
		cout << setw(4) << SQ->queue[i];
		i = (i + 1) % MaxSize;
	}
	cout << endl;
}

获取首元素

int getHead(SeqQueue* SQ, DataType* data) {
	if (!SQ || isEmpty(SQ)) {
		cout << "队列为空!" << endl;
	}
	return *data = SQ->queue[SQ->front];
}

清空队列

void clearQueue(SeqQueue* SQ) {
	if (!SQ) return;
	SQ->front = SQ->rear = 0;
}

队列长度

int getLength(SeqQueue* SQ) {
	if (!SQ) return 0;
	return (SQ->rear - SQ->front + MaxSize) % MaxSize;
}

测试

int main() {
	SeqQueue* SQ = new SeqQueue;
	DataType data = -1;
	//初始化队列
	initQueue(SQ);
	//入队
	for (int i = 0; i < 7; i++) {
		enterQueue(SQ, i);
	}
	//打印队列中的元素
	printf("队列中的元素(总共%d 个)：", getLength(SQ));
	printQueue(SQ);
	cout << endl;
	for (int i = 0; i < 5; i++) {
		if (outQueue(SQ, data)) {
			cout << "出队的元素是：" << data << endl;
		}
		else {
			cout << "出队失败！" << endl;
		}
	}
	
	printf("出队五个元素后，队列中剩下的元素个数为 %d 个：", getLength(SQ));
	printQueue(SQ);
	cout << endl;
	//入队 4 个
	for (int i = 0; i < 4; i++) {
		enterQueue(SQ, i + 10);
	}
	printf("\n 入队四个元素后，队列中剩下的元素个数为 %d 个：",
	getLength(SQ));
	printQueue(SQ);
	return 0;
}

优先队列

结构定义

#define MaxSize 5
typedef int DataType;
typedef struct _QNode {
	int priority;
	DataType data;
	struct _QNode* next;
}QNode;
typedef QNode* QueuePtr;
typedef struct Queue {
	int length;
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;

初始化

void initQueue(LinkQueue* LQ) {
	if (!LQ) return;
	LQ->front = LQ->rear = NULL;
	LQ->length = 0;
}

判断队空或队满

bool isEmpty(LinkQueue* LQ) {
	if (!LQ) return false;
	return LQ->front == NULL;
}

bool isFull(LinkQueue* LQ) {
	if (!LQ) return false;
	return LQ->length == MaxSize;
}

入队

bool enterQueue(LinkQueue* LQ,DataType data,int priority) {
	if (!LQ) return false;
	if (isFull(LQ)) {
		cout << "Queue is full !" << endl;
		return false;
	}
	QueuePtr qNode = new QNode;
	qNode->data = data;
	qNode->priority = priority;
	qNode->next = NULL;
	if (isEmpty(LQ)) {
		LQ->front = LQ->rear = qNode;
	}
	else {
		LQ->rear->next = qNode;
		LQ->rear = qNode;
	}
	LQ->length++;
	return true;
}

出队

bool outQueue(LinkQueue* LQ, DataType* data) {
	QNode** prev = NULL, * prev_node = NULL;
	QueuePtr last = NULL, tmp = NULL;
	if (isEmpty(LQ)) {
		cout << "Queue is empty !" << endl;
		return false;
	}
	prev = &(LQ->front);
	printf("第一个节点的优先级是：%d\n", (*prev)->priority);
	last = LQ->front;
	tmp = last->next;
	while (tmp) {
		if (tmp->priority > (*prev)->priority) {
			printf("抓到更大优先级的节点[priority: %d]\n", tmp->priority);
			prev = &(last->next);
			prev_node = last;
		}
		last = tmp;
		tmp = tmp->next;
	}
	*data = (*prev)->data;
	tmp = *prev;
	*prev = (*prev)->next;
	delete tmp;
	LQ->length--;
	//1.删除的是首节点,而且队列长度为零
	if (LQ->length == 0) {
		LQ->rear = NULL;
	}
	//2.删除的是尾部节点
	if (prev_node && prev_node->next == NULL) {
		LQ->rear = prev_node;
	}
	return true;
}

输出队

void printQueue(LinkQueue* LQ) {
	if (!LQ || LQ->front == NULL) {
		cout << "Queue is empty !" << endl;
		return;
	}
	QueuePtr tmp;
	tmp = LQ->front;
	while (tmp) {
		cout << setw(4) << tmp->data << "[" << tmp->priority << "]";
		tmp = tmp->next;
	}
	cout << endl;
}

获取首元素

DataType getHead(LinkQueue* LQ, DataType& data) {
	if (!LQ || isEmpty(LQ)) {
		cout << "Queue is empty !" << endl;
		return 0;
	}
	return data = LQ->front->data;
}

清空队列

void clearQueue(LinkQueue* LQ) {
	if (!LQ) return;
	while (LQ->front) {
		QueuePtr tmp = LQ->front->next;
		delete LQ->front;
		LQ->front = tmp;
	}
	LQ->front = LQ->rear = NULL;
	LQ->length = 0;
}

队列长度

int getLength(LinkQueue* LQ) {
	if (!LQ) return -1;
	return LQ->length;
}

测试

int main() {
	LinkQueue* LQ = new LinkQueue;
	DataType data = -1;
	//初始化队列
	initQueue(LQ);
	//入队
	for (int i = 0; i < 5; i++) {
		enterQueue(LQ, i + 10, i);
	}
	//打印队列中的元素
	printf("队列中的元素(总共%d 个)：", getLength(LQ));
	printQueue(LQ);
	cout << endl;
	//出队
	for (int i = 0; i < 5; i++) {
		if (outQueue(LQ, &data)) {
			cout << "出队的元素是：" << data << endl;
		}
		else {
			cout << "出队失败！" << endl;
		}
	}
	//打印队列中的元素
	printf("出队五个元素后，队列中剩下的元素[%d]：\n", getLength(LQ));
	printQueue(LQ);
	cout << endl;
	clearQueue(LQ);
	cout << "清空队列!\n";
	printQueue(LQ);
	delete LQ;
	return 0;
}

run sun
关注
专栏目录
数据结构---队列及其应用
CS专业追想日记
10-08 1491
实验目录一、实验目的二、实验内容三、实验步骤四、实验代码一、队列的定义二、算法的初始化和实现五、总结 一、实验目的 1.掌握队列的基本概念、基本操作和基本使用方式。 2.掌握循环队列的类型定义以及实现方法。 3.掌握循环队列的基本操作:初始化、入队、出队、队空判断、获取队头元素。 4.掌握循环队列的实现和简单应用。 5.能够清楚理解循环队列中空间的重用思想。 二、实验内容 1.设计和实现一个队列数据结构,且采用循环队列实现方法。 2.实现循环队列的各种操作,包括循环队列的初始化、出入队、清空和释放等。 3.
数据结构 -- 队列
weixin_48084293的博客
08-30 8298
文章目录什么是队列队列的顺序存储方式循环队列代码实现循环队列的顺序存储结构判断队列是否已满判断队列是否为空向队列中添加元素删除队列中的元素获取队头元素获取队列元素个数遍历元素整体代码 什么是队列 队列（queue）是只允许在一端进行插入操作，而另一端进行删除操作的线性表结构。 队列是一种先进先出的(First In First Out)的线性表，简称FIFO，允许插入的一段称为队尾，允许删除的一段称为队头。 假设存在队列 q=(a1,a2,a3…an)， 则a1为队头元素，an为队尾元素，删除时总是删除
数据结构-链队列的基础操作
m0_52118763的博客
12-28 3464
1.队列的定义   队列 (Queue)是另一种限定性的线性表，它只允许在表的一端插入元素，而在另一端删除元素，所以队列具有先进先出(Fist In Fist Out，缩写为FIFO)的特性。在队列中，允许插入的一端叫做队尾(rear)，允许删除的一端则称为队头(front)。 假设队列为q=(a1，a2，…，an)，那么a1就是队头元素，an则是队尾元素。队列中的元素是按照a1、a2、…、an的顺序进入的， 退出队列也必须按照同样的次序依次出队，也就是说，只有在a1、a2、…、an-1都离开队列之后，an
数据结构基础-队列（循环队列、链式队列）以及STL中queue的使用
MirrorN的博客
02-10 2511
对于队列（Queue）是什么，再次不再赘述，与链表、栈的实现一样，队列作为一种特殊的线性表，也存在顺序存储以及链式存储两种方式。 顺序存储的队列 采用顺序存储的方式来存储队列，最简单的方式是对于n个元素的队列，开辟一个n大小的数组，入队操作即是在数组的尾部直接添加元素，出队操作即将0方向的元素移除，并将所有的后边元素全部前移一个，这与顺序表操作是一致的，但是自然会很麻烦，因此，又出现了另一...
数据结构：队列
weixin_49965654的博客
07-22 1534
好了，队列的数据结构到这里就差不多结束了，总体来说当我们有顺序表和链表的基础之后，队列这个数据结构相对来说还是非常简单的。最后大家一定要多动手操作，一定要自己手敲一遍。求三连！！！！！！
C++基础数据结构——队列
2301_79967286的博客
07-24 2369
队列，滑动窗口与单调队列，最大子序和问题。
数据结构-循环队列的基础操作
m0_52118763的博客
12-29 2165
首先先看一下普通的顺序队列 会发现出队后，前面的几个单元不能利用，浪费了空间，如果可以使队列首尾相接就可以解决这个问题了 如何区分队列“空”和“满” 1.另设一个标志位以区分队列是空还是满； 2.少用一个元素空间，当队列头指针在队列尾指针的下一个位置上时为“满”。 当Q.front=Q.rear时队空；Q. rear+1=Q. front时队满 循环队列满足条件 (Q.rear+1)%MAXQSIZE= = Q.front 队满 循环队列的类型定义： #define MAXQSIZE 100 /*队列的
数据结构--栈，队列
includeevey的博客
08-08 1991
一篇好的文章离不开你的观看
【数据结构】线性表----队列详解
Skrrapper的博客
07-11 1468
队列作为一种重要的数据结构，具有简单但实用的特性。在本文中，我们介绍了队列的基本概念、实现方法、常见操作、实际应用以及使用时需要注意的问题。通过实践代码示例，相信读者能更好地理解和掌握队列的使用。队列在编程中的应用广泛，相信掌握了它将为你的编程技能打下坚实的基础。
嵌入式常用数据结构------队列操作简介
08-21
总结来说，队列作为基础数据结构在嵌入式开发中扮演着重要角色。它简化了顺序处理逻辑，使得数据处理更加高效和有序。理解和熟练运用队列的各种操作，对于提升嵌入式系统的性能和可靠性至关重要。
数据结构学习-队列/栈
04-28
### 数据结构学习——队列与栈 ...通过以上介绍可以看出，队列和栈都是基础且重要的数据结构，在程序设计中有着不可替代的作用。理解它们的基本概念和实现方法，对于提高编程能力和解决实际问题具有重要意义。
数据结构--队列实验报告.docx
06-20
### 数据结构——队列实验报告知识点总结 #### 一、队列基础知识 - **队列定义**：队列是一种特殊的线性表，只允许在一端进行插入操作，在另一端进行删除操作。允许插入的一端称为队尾（rear），允许删除的一端称为...
嵌入式常用数据结构------队列操作简介.docx
04-18
队列是一种线性数据结构，它遵循先进先出...总结起来，队列作为一种基础数据结构，对于理解嵌入式系统的工作原理和优化系统性能具有重要意义。在实际编程中，正确地实现和使用队列操作能够有效提高系统的效率和稳定性。
C~排序算法
最新发布
weixin_60461563的博客
09-27 723
在C/C++中，有多种排序算法可供选择，每种算法都有其特定的应用场景和特点。下面介绍几种常用的排序算法，包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序，并给出相应的示例代码和解释。
数据结构：树、森林
pranaa的博客
09-24 813
此外，访问子节点和父节点的索引计算也会变得复杂，因为需要额外的数据结构（如指针或索引数组）来跟踪每个节点的子节点位置。在转换为二叉树时，我们可以将节点的第一个孩子视为二叉树的左孩子，将节点的下一个兄弟视为二叉树的右孩子。这种转换在处理树形结构的问题时非常有用，因为二叉树具有一些特殊的性质（如左子树和右子树的明确区分）和高效的算法（如二叉搜索树、堆等）。二叉树和树的顺序存储结构在本质上是相似的，但由于二叉树结构的特殊性，它在顺序存储中更加高效和直接。二叉树转换为树的过程是上述转换的逆过程。
考研数据结构——C语言实现插入排序
weixin_58879477的博客
09-24 373
C语言实现插入排序
数据结构：特殊矩阵 及其存储
pranaa的博客
09-23 759
特殊矩阵的压缩存储是一种优化存储空间的技术，主要针对具有许多相同矩阵元素或零元素，且这些元素分布具有一定规律性的矩阵。这些矩阵包括对称矩阵、三角矩阵（上三角矩阵和下三角矩阵）、对角矩阵（如三对角矩阵）以及稀疏矩阵等。以下是对这些特殊矩阵压缩存储的详细介绍及例子。
数据结构：什么是数据类型（详解）
pranaa的博客
09-22 358
数据类型（Data Type）是编程中的一个基本概念，它定义了数据的种类和存储方式，以及可以对该数据执行的操作。在编程中，不同的数据类型允许程序员以不同的方式存储和操作数据。数据类型决定了数据的性质、大小、如何解释存储的位（bit）以及可以对这些数据执行哪些操作。数据类型主要分为两大类：基本数据类型（Primitive Data Types）和复合数据类型（Composite Data Types）。
数据结构-循环队列详解
循环队列是一种在计算机科学中广泛使用的数据结构，它在顺序存储结构的基础上进行扩展，解决了传统队列在满和空状态下的判断二义性问题。在循环队列中，元素在数组中以环形方式组织，当队列的后端（rear）追上前端...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

run sun

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值