数据结构：链式队和循环队的原理，实现及实际应用

已于 2024-05-24 23:05:39 修改
阅读量1k 收藏 12
点赞数 10
分类专栏： 数据结构与算法 文章标签： 数据结构 队列 循环队 链式队 队列的运用 C语言 学习
于 2024-05-24 17:38:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zhihuiguoz/article/details/139102700
版权

✨✨小新课堂开课了，欢迎欢迎~✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：数据结构与算法

小新的主页：编程版小新-CSDN博客

1.队列的定义

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表。队列严格遵循先进先出FIFO(First In First Out)的原则。

入队列：进行插入操作的一端称为队尾

出队列：进行删除操作的一端称为队头

2.队列的分类 

队列的实现其实就和前面学习的栈一样，分为单链表实现实现的链式队，和数组实现的循环队。他们各有好处，也有需要细节需要注意。

1.链式队

我们用两个指针控制这个链表的头和尾，就能够实现队列的相关功能，为了方便计算队列的大小，我们也可以添加一个size来记录队列的大小。

2.循环队 

我们在用数组实现栈的时候，使用的是一般的数组，我们用两个变量记录数组的起始位置和结束位置，但是一般的数组有能解决问题吗？如果不能存在什么问题，以及我们该怎么解决呢？接下来让我们一起去探索吧。

由此可以观察到，当在不断入队和出队后，前面的空间就会被浪费，不能在被使用。

为了解决这个问题我们可以使用循环数组。

 循环数组虽然解决了上面的空间浪费的问题，但由此又产生了一个新的问题，我们该如何计算队列的大小呢？当head和tail指向同一个位置时队列为空还是为满呢？

第一种：牺牲一个单元来区分队空和队满，每当入队时tail++，当tail指向的下一个位置是head时即tail+1==head时，此时队列已满。每当出队时head++，当head==tail时，表示队列为空。

第二种：增添一个记录队列大小的变量size 。这样，队空的条件为 size==0；队满的条件为size==MaxSize。

3.队列的功能 

1.队列的初始化

2.判断队列是否为空

3.判断队列是否为满

4.入队

5.出队

6.返回队头和队尾的数据

7.返回队列的大小

8.打印队列

9.销毁队列

4.队列的声明 

1.链式队

//队列的声明
typedef int QDataType;
typedef struct QueueNode
{
	QDataType x;
	struct QueueNode* next;
}QueueNode;

typedef struct QueueNode* PQueueNode;

typedef struct Queue
{
	PQueueNode head;
	PQueueNode tail;
	int size;
}Queue;

2.循环队

//队列的声明
typedef int QDataType;
#define MAXSIZE 50

typedef struct Queue
{
	QDataType* data;
	int head;
	int tail;
}Queue;

5.功能实现

5.1队列的初始化

1.链式队

//队列的初始化
void QueueInit(Queue* pst)
{
	pst->head = NULL;
	pst->tail = NULL;
	pst->size = 0;
}

2.循环队

//队列的初始化
void QueueInit(Queue* pst)
{
	assert(pst);
	pst->data = (QDataType*)malloc(sizeof(QDataType)*MAXSIZE);
	if (pst->data == NULL)
	{
		perror("malloc fail");
		return;
	}
	pst->head = 0;
	pst->tail = 0;
}

5.2判断队列是否为空

1.链式队

//判断队列是否为空
bool QueueEmpty(Queue* pst)
{
	assert(pst);
	return pst->size == 0;
}

2.循环队

进行取模操作是为了防止越界访问，实现数组的回绕，即实现循环的功能。

//判断队列是否为空
bool QueueEmpty(Queue* pst)
{
	assert(pst);
	return (pst->head % MAXSIZE) == (pst->tail % MAXSIZE);
}

5.3判断队列是否为满

1.链式队

链式队是按需申请空间，不存在为满的情况。

2.循环队

按照我们上面分析的为满的情况实现即可，这里及其下面的取模操作都是为了防止越界访问。

//判断队列是否为满
bool QueueFull(Queue* pst)
{
	assert(pst);
	return ((pst->tail + 1) % MAXSIZE) == (pst->head % MAXSIZE);
}

5.4入队

1.链式队

//入队
void QueuePush(Queue* pst, QDataType x)
{
	assert(pst);
	PQueueNode newnode = (PQueueNode)malloc(sizeof(QueueNode));
	newnode->next = NULL;
	newnode->x = x;
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}

	if (QueueEmpty(pst))
	{
		pst->head = pst->tail = newnode;
	}
	else
	{
		pst->tail->next = newnode;
		pst->tail = newnode;
	}
	pst->size++;
}

2.循环队

插入前要判满。

//入队
void QueuePush(Queue* pst, QDataType x)
{
	assert(pst);
	assert(!QueueFull(pst));
	pst->data[pst->tail] = x;
	pst->tail = (pst->tail + 1) % MAXSIZE;

}

5.5出队

1.链式队

在出队的时候分为两种情况，只有一个节点时和多个节点时，要进行分开处理。

//出队
void QueuePop(Queue* pst)
{
	assert(pst);
	assert(!QueueEmpty(pst));
	//1.只有一个节点
	if (pst->head == pst->tail)
	{
		free(pst->head);
		pst->head = pst->tail = NULL;
	}
	else
	{
		//2.有多个节点
		PQueueNode del = pst->head;
		pst->head = pst->head->next;
		free(del);
		del = NULL;
	}
	pst->size--;
}

2.循环队

//出队
void QueuePop(Queue* pst)
{
	assert(pst);
	assert(!QueueEmpty(pst));
	pst->head = (pst->head + 1) % MAXSIZE;
	
}

5.6返回队头和队尾的数据

1、链式队

//返回对头的数据
QDataType QueueFront(Queue* pst)
{
	assert(pst);
	assert(!QueueEmpty(pst));
	return pst->head->x;
}

//返回队尾数据
QDataType QueueBack(Queue* pst)
{
	assert(pst);
	assert(!QueueEmpty(pst));
	return pst->tail->x;
}

2.循环队

在返回队尾数据时，因为我们是没入一次队pst->tail++,所以在返回队尾数据时，pst->tail要先减去1，但是这里有可能在不断入队出队后，pst->tail=0，减1的话就会越界，而(pst->tail-1+MAXSIZE) % MAXSIZE就避免了这个问题。

//返回对头的数据
QDataType QueueFront(Queue* pst)
{
	assert(pst);
	assert(!QueueEmpty(pst));
	return pst->data[pst->head%MAXSIZE];
}

//返回队尾数据
QDataType QueueBack(Queue* pst)
{
	assert(pst);
	assert(!QueueEmpty(pst));
	return pst->data[(pst->tail-1+MAXSIZE) % MAXSIZE];
}

5.7返回队列的大小

1.链式队

//返回队列的大小
int QueueSize(Queue* pst)
{
	assert(pst);
	return pst->size;
}

2.循环队

//返回队列的大小
int QueueSize(Queue* pst)
{
	return (pst->tail + MAXSIZE- pst->head) % MAXSIZE;
}

5.8打印队列

1.链式队

//打印队列的元素
void QueuePrint(Queue* pst) 
{
	assert(pst);
	assert(pst->size > 0);
	PQueueNode cur = pst->head;
	printf("队头->");
	while (cur != pst->tail->next)
	{
		printf("%d->", cur->x);
		cur = cur->next;
	}
	printf("队尾\n");
}

2.循环队

//打印队列的元素
void QueuePrint(Queue* pst)
{
	assert(pst);
	assert(!QueueEmpty(pst));
	int cur = pst->head;
	printf("对头->");
	while (cur!=pst->tail)
	{
		printf("%d->", pst->data[cur]);
		cur = (cur + 1) % MAXSIZE;
	}
	printf("队尾\n");
}

5.9销毁队列

1.链式队

因为链式队时一个个节点来实现的，在销毁队列时就要一个一个去释放。

//销毁队列
void QueueDestroy(Queue* pst)
{
	assert(pst);
	PQueueNode cur = pst->head;
	while (cur != NULL)
	{
		PQueueNode del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
	pst->head = pst->tail = NULL;
	pst->size = 0;
}

2.循环队

只要将整体开辟的一个空间释放即可。

//销毁队列
void QueueDestroy(Queue* pst)
{
	assert(!QueueEmpty(pst));
	free(pst->data);
	pst->data = NULL;
	pst->head = pst->tail = 0;
}

6.链式队和循环队的对比 

7.队列的实际应用

1.吃饭排队取号

2.好友推荐也有队列的身影

8.完整代码

1.链式队

Queue.h

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>

//链式队

//队列的声明
typedef int QDataType;
typedef struct QueueNode
{
	QDataType x;
	struct QueueNode* next;
}QueueNode;

typedef struct QueueNode* PQueueNode;

typedef struct Queue
{
	PQueueNode head;
	PQueueNode tail;
	int size;
}Queue;

//队列的初始化
void QueueInit(Queue* pst);

//判断队列是否为空
bool QueueEmpty(Queue* pst);

//判断队列是否为满
//bool QueueFull(Queue* pst);

//入队
void QueuePush(Queue* pst, QDataType x);

//出队
void QueuePop(Queue* pst);

//返回对头的数据
QDataType QueueFront(Queue* pst);

//返回队尾数据
QDataType QueueBack(Queue* pst);

//返回队列的大小
int QueueSize(Queue* pst);

//打印队列的元素
void QueuePrint(Queue* pst);

//销毁队列
void QueueDestroy(Queue* pst);

Queue.c

#include"Queue.h"

//队列的初始化
void QueueInit(Queue* pst)
{
	pst->head = NULL;
	pst->tail = NULL;
	pst->size = 0;
}

//判断队列是否为空
bool QueueEmpty(Queue* pst)
{
	assert(pst);
	return pst->size == 0;
}

//判断队列是否为满
//链式队不存在判满的情况

//入队
void QueuePush(Queue* pst, QDataType x)
{
	assert(pst);
	PQueueNode newnode = (PQueueNode)malloc(sizeof(QueueNode));
	newnode->next = NULL;
	newnode->x = x;
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}

	if (QueueEmpty(pst))
	{
		pst->head = pst->tail = newnode;
	}
	else
	{
		pst->tail->next = newnode;
		pst->tail = newnode;
	}
	pst->size++;
}

//出队
void QueuePop(Queue* pst)
{
	assert(pst);
	assert(!QueueEmpty(pst));
	//1.只有一个节点
	if (pst->head == pst->tail)
	{
		free(pst->head);
		pst->head = pst->tail = NULL;
	}
	else
	{
		//2.有多个节点
		PQueueNode del = pst->head;
		pst->head = pst->head->next;
		free(del);
		del = NULL;
	}
	pst->size--;
}

//返回对头的数据
QDataType QueueFront(Queue* pst)
{
	assert(pst);
	assert(!QueueEmpty(pst));
	return pst->head->x;
}

//返回队尾数据
QDataType QueueBack(Queue* pst)
{
	assert(pst);
	assert(!QueueEmpty(pst));
	return pst->tail->x;
}

//返回队列的大小
int QueueSize(Queue* pst)
{
	assert(pst);
	return pst->size;
}

//打印队列的元素
void QueuePrint(Queue* pst) 
{
	assert(pst);
	assert(pst->size > 0);
	PQueueNode cur = pst->head;
	printf("队头->");
	while (cur != pst->tail->next)
	{
		printf("%d->", cur->x);
		cur = cur->next;
	}
	printf("队尾\n");
}

//销毁队列
void QueueDestroy(Queue* pst)
{
	assert(pst);
	PQueueNode cur = pst->head;
	while (cur != NULL)
	{
		PQueueNode del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
	pst->head = pst->tail = NULL;
	pst->size = 0;
}

2.循环队

Queue.h

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

//队列的声明
typedef int QDataType;
#define MAXSIZE 50

typedef struct Queue
{
	QDataType* data;
	int head;
	int tail;
}Queue;

//队列的初始化
void QueueInit(Queue* pst);

//判断队列是否为空
bool QueueEmpty(Queue* pst);

//判断队列是否为满
bool QueueFull(Queue* pst);

//入队
void QueuePush(Queue* pst, QDataType x);

//出队
void QueuePop(Queue* pst);

//返回对头的数据
QDataType QueueFront(Queue* pst);

//返回队尾数据
QDataType QueueBack(Queue* pst);

//返回队列的大小
int QueueSize(Queue* pst);

//打印队列的元素
void QueuePrint(Queue* pst);

//销毁队列
void QueueDestroy(Queue* pst);

Queue.c

#include"Queue.h"

//循环队（基于数组实现）

//队列的初始化
void QueueInit(Queue* pst)
{
	assert(pst);
	pst->data = (QDataType*)malloc(sizeof(QDataType)*MAXSIZE);
	if (pst->data == NULL)
	{
		perror("malloc fail");
		return;
	}
	pst->head = 0;
	pst->tail = 0;
}

//判断队列是否为空
bool QueueEmpty(Queue* pst)
{
	assert(pst);
	return (pst->head % MAXSIZE) == (pst->tail % MAXSIZE);
}

//判断队列是否为满
bool QueueFull(Queue* pst)
{
	assert(pst);
	return ((pst->tail + 1) % MAXSIZE) == (pst->head % MAXSIZE);
}

//入队
void QueuePush(Queue* pst, QDataType x)
{
	assert(pst);
	assert(!QueueFull(pst));
	pst->data[pst->tail] = x;
	pst->tail = (pst->tail + 1) % MAXSIZE;

}
//出队
void QueuePop(Queue* pst)
{
	assert(pst);
	assert(!QueueEmpty(pst));
	pst->head = (pst->head + 1) % MAXSIZE;
	
}

//返回对头的数据
QDataType QueueFront(Queue* pst)
{
	assert(pst);
	assert(!QueueEmpty(pst));
	return pst->data[pst->head%MAXSIZE];
}

//返回队尾数据
QDataType QueueBack(Queue* pst)
{
	assert(pst);
	assert(!QueueEmpty(pst));
	return pst->data[(pst->tail-1+MAXSIZE) % MAXSIZE];
}

//返回队列的大小
int QueueSize(Queue* pst)
{
	return (pst->tail + MAXSIZE- pst->head) % MAXSIZE;
}

//打印队列的元素
void QueuePrint(Queue* pst)
{
	assert(pst);
	assert(!QueueEmpty(pst));
	int cur = pst->head;
	printf("对头->");
	while (cur!=pst->tail)
	{
		printf("%d->", pst->data[cur]);
		cur = (cur + 1) % MAXSIZE;
	}
	printf("队尾\n");
}

//销毁队列
void QueueDestroy(Queue* pst)
{
	assert(!QueueEmpty(pst));
	free(pst->data);
	pst->data = NULL;
	pst->head = pst->tail = 0;
}

编程版小新
关注
  • 10
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链式栈与循环队列
Mars1997的博客
05-09 372
链式栈是一种数据存储结构，可以通过单链表的方式来实现，使用链式栈的优点在于它能够克服用数组实现的顺序栈空间利用率不高的特点，但是需要为每个栈元素分配额外的指针空间用来存放指针域。 链式栈的定义及其基本操作： package practice; /*入栈使用头结点 * 出栈只用删除head.next * * */ class LinkStack1{ class Entry{ ...
数据结构——链式循环队列
zswsx123的博客
02-03 299
#include<iostream> #include<math.h> using namespace std; #define SIZE 10 #pragma warning(disable:4996) typedef struct l { char data; struct l* next; }node; typedef struct I { node *front; node *rear; }List; void openlist(List &L);//初始化队
数据结构-----循环队列 链式队列
FDk_LCL的博客
04-02 2636
目录 队列的定义 顺序队列 循环队列 循环队列的实现 链式队列 链式队列的实现 队列的定义 队列是一种只允许一端进行插入操作，一端只允许进行删除操作的线性表。 队列是一种先进先出（FIFO）的线性表，它只允许在表的一端进行插入和在表的另一端删除元素。在队列中，允许插入的一段叫做队尾（rear），允许删除的一端叫做队头（front）。假设队列为q = (a...
循环队列（链式表示和实现）
weixin_47700137的博客
07-21 2281
链队是指采用链式存储结构实现的队列。通常链队用单链表来表示，如下图所示。一个链队显然需要两个分别指向队头和队尾的指针（分别称为头指针和尾指针）才能唯一确定。这里和线性表的单链表一样。为了操作方便起见，给链队添加一个头节点，并令头指针始终指向头结点。 下面是队列操作的指针变化状况 C++代码 #include<iostream> using namespace std; typedef struct qNode { int data; struct qNode *next; }qNode,
数据结构--链式循环队列
kingJamesbond的博客
11-30 2491
题目要求 循环链表队列 假设以带头点的循环链表表示队列，链表长度为n，设置头指针和尾指针，试编写相应的队列初始化、入队和出队的算法； 实现要求： 1、输入循环链表长度n； 2、入队m个元素； 3、打印队列中所有元素； 4、出队k个元素； 5、打印队列中的元素； 6、销毁队列。 范例 输入： 8 6 1 2 3 4 5 6 3 输出： 1 2 3 4 5 6 4 5 6 知识简介 队列的定义：只允许在一段进行插入操作，在另一端进行删除操作 特点：先进先出 允许插入的一头为队尾（rear)，允许进行删除的是队
djb.rar_C++_c 循环 队列_数据队列_链式队列_队列 数据结构
09-23
5. **队列_数据结构**：队列作为一种基础数据结构，对于理解和实现复杂算法至关重要。它在计算机科学中有着广泛的应用，如缓冲区管理、打印任务队列、深度优先搜索（DFS）等。 在提供的源代码中，你可以看到如何...
C语言实现数据结构：单链表，循环链表，双向链表；静态顺序队列
10-19
在IT领域，数据结构是计算机科学中的核心概念，它...在C_DataStructure-master这个项目中，你可以找到这些数据结构的具体C语言实现，通过阅读源代码，可以加深对它们的理解，并学习如何在实际编程中应用这些基础知识。
数据结构：第三章 栈和队列.ppt
06-10
循环队列是队列的一种优化形式，它可以更有效地处理边界条件，避免了数组满或空的情况，通过循环使用数组空间来实现连续的入队和出队操作。 总的来说，理解和掌握栈和队列的基本概念、操作及其应用对于任何IT专业...
C语言实现队列源码，包含顺序队列，链式队列，循环队列，亲测可用
04-25
总的来说，掌握队列及其在C语言中的实现对于理解和应用数据结构至关重要。无论是顺序队列的高效数组操作，链式队列的灵活节点链接，还是循环队列的空间优化，都是程序员在解决实际问题时的有力工具。通过阅读和理解...
所有基础数据结构和算法的纯C语言实现.zip
最新发布
04-27
在C语言中实现这些数据结构和算法，不仅可以深入理解其内部工作原理，还能锻炼编程技巧。这个压缩包中的"SJT-code"文件夹很可能是包含这些实现的源代码，可以直接阅读和学习，或者作为开发项目时的参考。通过实际...
java队列实现（顺序队列、链式队列、循环队列）
07-27
java队列实现（顺序队列、链式队列、循环队列）
链式循环队列实现（C语言）
wutiankesiyry1的博客
10-09 480
欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
数据结构-【队列】链式队列和循环队列
行而不辍，未来可期 - King
09-10 871
队列特性：先进先出（FIFO)——先进队列的元素先出队列。来源于我们生活中的队列（先排队的先办完事）。
队列（链式队列和循环队列）
m0_64017524的博客
05-17 908
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头 一.链式队列 链式队列则为单链表方式存储，输入队时从堆中动态申请及释放内存，可避免预置空间造成资源浪费及空间不够造成的队满溢出，但是需要多余的指针域空间。出入队即为单链表节点的插入删除操作，需注意数据取出的方式及时机。 在我看来链式队列就是在一个单链表的基础上，多加了一个一个结构体指针用来表示
循环队列-队列的链式表示及实现
wxdn_xm的博客
09-16 358
#include<iostream> using namespace std; #define MAXQSIZE 100 //q.rear+1=q.front则队列满 typedef struct { int *base;//循环链表空间 int front;//头指针,指向首元素，直接用下标指向链表空间,因此循环队列是基于数组实现的 int rear;//尾指针，指向最后一个元...
数据结构--队列(循环，链式)
weixin_45461859的博客
04-11 176
队列的定义 队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表 队列是一种先进先出的线性表(FIFO) 允许插入的一端称为队尾，允许删除的一端称为队头 线性表有顺序存储和链式存储，队列作为一种特殊的线性表，也同样存在这两种存储方式 循环队列 队列顺序存储有很多不足，我们用两个指针对位置进行标记，front指向第一个元素的位置，rear指向最后一个元素的下一个位置 我们添加元素时，...
链队列和循环队列（c语言数据结构）
awm123453的博客
05-17 426
一、链队列： 链队是指采用链式存储结果实现的队列，通常用单链表来表示。一个链队需要两个分别指示队头和队尾的指针才能确定。 代码： #include <stdio.h> #include <malloc.h> //链队列的节点 typedef struct LinkNode{ int data; LinkNode* next; }*LinkNodePtr; //链队列. typedef struct LinkQueue{ LinkNodePtr front; LinkN
数据结构---------循环队列与链式队列
bobopeng
10-18 913
1.循环队列有几个初学者需要注意的地方： （1）如何判断循环队列为空或者已满？ 其实在程序设计的过程中是有很多方法来处理同一个问题的，就看编写代码者如何去处理。一般情况下，有两种方法来处理循环队列的这个问题: a.在循环队列的定义过程中，用一个变量来记录当前队列中元素的个数； b.利用 (Q->front + 1)%MaxSize == Q->rear来判断是否已满；利用Q->front
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值