限定性线性表——队列

于 2024-04-13 17:17:13 发布
阅读量887 收藏 27
点赞数 32
分类专栏： 数据结构 文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_55869380/article/details/137435549
版权
本文使用C语言在Visual Studio 2022中实现队列。先介绍队列定义，它具有先进先出特性。接着详细阐述链队的表示和实现，包括结点结构、初始化、判空、入队、出队等操作及代码。最后讲解循环队列的表示和实现，涵盖结点结构、初始化、判满等操作及代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  • 语言：C语言
  • 软件：Visual Studio 2022
  • 笔记书籍：数据结构——用C语言描述
  • 如有错误，感谢指正。若有侵权请联系博主

一、队列的定义

队列是另一种限定性线性表，它只允许在表的一端插入元素，而在表的另一端删除元素，所以队列具有先进先出的特性。这与我们日常生活中的排队是一样的，最早进入队列的人最先离开，新来的人总是加入队尾。在队列中，允许插入的一端称为队尾，允许删除的一端则称为队头。

下面给出队列的抽象数据定义：
 

ADT Queue{
    数据对象：可以是任意类型的数据，但必须性质相同。
    结构关系：队列中数据元素之间是线性关系。
    基本操作：
    1、InitQueue(Q)
       操作前提：Q为未初始化的队列。
       操作结果：将Q初始化为一个空队列。
    2、IsEmpty(Q)
       操作前提：队列Q已经存在。
       操作结果：若队列为空，则返回TRUE,否则返回FALSE。
    3、IsFull(Q)
       操作前提：队列Q已经存在。
       操作结果：若队列为满，则返回TRUE，否则返回FALSE。
    4、EnterQueue(Q,x)
       操作前提：队列Q已经存在。
       操作结果：在队列Q的队尾插入x。操作成功，返回值为TRUE，否则返回值为FALSE。
    5、DeleteQueue(Q,x)
       操作前提：队列Q已经存在。
       操作结果：将队列Q的队头元素出队，并用x带回其值。操作成功，返回值为TRUE，否则返回值为FALSE。
    6、GetHeat(Q,x)
       操作前提：队列Q已经存在。
       操作结果：取队列Q的对头元素(该元素不出队)，并用x带回其值。操作成功，返回值为TRUE，否则返回值为FALSE。
    7、ClearQueue(Q)
       操作前提：队列Q已经存在。
       操作结果：将队列Q置为空队列。
}ADT Queue;

二、链队的表示和实现

1、链队列结点结构

说明：为了操作方便采用带头节点的链表结构，并设置一个队头指针font和一个队尾指针rear，对头指针始终指向头节点，队尾指针指向最后一个元素。对于空的链队列，队头指针和队尾指针均指向头结点。

93548db5b6204c4db37594549f199ed7.png

链队列

//结点的结构
typedef struct Node
{
	QueueElementType data;
	struct Node* next;
}LinkQueueNode;
//头指针尾指针结构
typedef struct
{
	LinkQueueNode* front;
	LinkQueueNode* rear;
}LinkQueue;

2、InitQueue初始化队列

/*初始化队列*/
int InitQueue(LinkQueue *Q) {
	Q->front = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
	if (Q->front != NULL) {
		Q->rear = Q->front;
		Q->front->next = NULL;
		return (TRUE);
	}
	else return (FALSE);
}

说明：

第三行：开辟一个新的结构体空间（头结点），并将头节点赋值给头指针。

第四行：判断开辟的头结点是否为空，这里是考虑到有可能空间满了，没法再分配内存了。

第五、六、七行：全是满足条件执行的，先将队头指针指向的地址赋值给队尾指针指向的地址，即空链队的队头指针和队尾指针均指向头结点。再将创建的头结点的指针域置空。最后一个是返回结果，结束函数。

第九行：开辟的空间为空，即没开辟空间，返回FALSE结束循环。

3、IsEmpty判断队列是否为空

/*队列判空*/
int IsEmpty(LinkQueue* Q) {
	if (Q->front->next == NULL) return (TRUE);
	return (FALSE);
}

说明：

第三行：对头结点的指针域是否为空进行判断，若为空则队列为空返回 TRUE，否则返回FALSE。这一行也可以改为判断对头指针和队尾指针是否都指向同一个结点来判断。后边出队操作中用的第二个方法。

4、IsFull队列判满

链的特性，只要内存足够可以一直往队列里存储数据

5、EnterQueue链队列入队操作

/*链队列入队操作*/
int EnterQueue(LinkQueue* Q, QueueElementType x) {
	LinkQueueNode* r = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
	if (r == NULL) return (FALSE);
	r->data = x;
	r->next = NULL;
	Q->rear->next = r;
	Q->rear = r;
	return (TRUE);
}

说明：

第三行：声明一个结点指针，并为该结点指针开辟空间赋值。

第四行：判断是否开辟成功，若没开辟空间，则r就为空，结束函数，否则执行后续代码。

第五行：将参数x的数据赋值给开辟的结点中的数据域。

第六行：将指针域置空。

第七行：将新结点赋值给队尾指针所指向的结点的指针域。

第八行：将新结点地址赋值给队尾指针。

最后返回 TRUE，表示入队操作成功。

6、 DeleteQueue链队列出队操作

/*链队列出队操作*/
int DeleteQueue(LinkQueue* Q, QueueElementType* x) {
	if (Q->front == Q->rear) return (FALSE);
	LinkQueueNode* r;
	r = Q->front->next;
	Q->front->next = r->next;
	if (Q->rear == r)
		Q->rear = Q->front;
	*x = r->data;
	free(r);
	return (TRUE);
}

说明：

第三行：最开始判断队列是否为空队列，若为空，直接返回FALSE，结束函数。

第四行：声明一个结点类型指针，用于存储出队的结点。

第五行：将头指针指向的头结点的指针域地址赋值给上一行声明的r指针。

第六行：将需要取出的结点的指针域数据赋值给头结点（Q->front）的指针域。即更新了头结点指针域所指向的地址。至此，将队列中队头数据取出，赋值在r中。

第七、八行：判断取出的这个结点是否为最后一个结点，若是最后一个结点，则需要即将队尾指针指向头节点。

第九行：将取出的结点中的数据取出赋值给参数x，这里必须用指针，函数形参和实参是值传递；

第十行：用free函数释放该该结点空间，即数据取出了销毁存储数据的空间，防止内存泄漏。

第十一行：返回TRUE，函数结束。

7、GetHead取队头操作

/*队列取对头元素*/
int GetHead(LinkQueue* Q, QueueElementType* x) {
	if (Q->front == Q->rear) return (FALSE);
	*x = Q->front->next->data;
	return (TRUE);
}

说明：

第三行：判断是否为空队列，若为空，返回FALSE直接结束函数。

第四行：将头首元结点的数据值赋值给x。Q->front是头结点，头结点的指针域（即Q->front->next）指向的是首元结点。

第五行：返回TRUE 函数结束。

8、ClearQueue队列置空操作

/*置空队列*/
int CleaQueue(LinkQueue* Q) {
	if (Q->front == Q->rear) return (FALSE);
	LinkQueueNode* r;
	r = Q->front->next;
	Q->front->next = r->next;
	while (Q->rear != r) {
		free(r);
		r = Q->front->next;
		Q->front->next = r->next;
	}
	free(r);
	Q->rear = Q->front;
	return (TRUE);
}

说明：

第三行：判断队列是否为空，若为空返回FALSE结束函数。

第四行：声明一个结点指针用于存储需要删除的结点。

第五行：将队列的队头赋值给声明的结点r，为了初始化结点r，便于while循环内判断。

第六行：更新队头数据。

第七行：判断需删除的结点是否是队尾，若是队尾，则跳出循环，不是队尾，持续循环。

第八行：将取出的队头空间删除释放。

第九行：再将队头指针赋值给声明的结点r。

第十行：更新队头数据。

第十二行：若链队内结点全删除，只剩最后一个结点，即跳出循环执行这一行。将最后一个结点的空间释放。

第十三行：将队尾指针指向头节点。

第十四行：返回TRUE，函数结束。

9、链队列的全套代码

#include <iostream>
#include <stdio.h>

#define QueueElementType int
#define TRUE 1
#define FALSE 0

typedef struct Node
{
	QueueElementType data;
	struct Node* next;
}LinkQueueNode;

//对头指针与队尾指针
typedef struct
{
	LinkQueueNode* front;
	LinkQueueNode* rear;
}LinkQueue;

/*初始化队列*/
int InitQueue(LinkQueue *Q) {
	Q->front = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
	if (Q->front != NULL) {
		Q->rear = Q->front;
		Q->front->next = NULL;
		return (TRUE);
	}
	else return (FALSE);
}

/*队列判空*/
int IsEmpty(LinkQueue* Q) {
	if (Q->front->next == NULL) return (TRUE);
	return (FALSE);
}

/*链队列入队操作*/
int EnterQueue(LinkQueue* Q, QueueElementType x) {
	LinkQueueNode* r = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
	if (r == NULL) return (FALSE);
	r->data = x;
	r->next = NULL;
	Q->rear->next = r;
	Q->rear = r;
	return (TRUE);
}

/*链队列出队操作*/
int DeleteQueue(LinkQueue* Q, QueueElementType* x) {
	if (Q->front == Q->rear) return (FALSE);
	LinkQueueNode* r;
	r = Q->front->next;
	Q->front->next = r->next;
	if (Q->rear == r)
		Q->rear = Q->front;
	*x = r->data;
	free(r);
	return (TRUE);
}

/*队列取对头元素*/
int GetHead(LinkQueue* Q, QueueElementType* x) {
	if (Q->front == Q->rear) return (FALSE);
	*x = Q->front->next->data;
	return (TRUE);
}

/*置空队列*/
int CleaQueue(LinkQueue* Q) {
	if (Q->front == Q->rear) return (FALSE);
	LinkQueueNode* r;
	r = Q->front->next;
	Q->front->next = r->next;
	while (Q->rear != r) {
		free(r);
		r = Q->front->next;
		Q->front->next = r->next;
	}
	free(r);
	Q->rear = Q->front;
	return (TRUE);
}

/*打印队列里的数据*/
int PrintLinkQueue(LinkQueue* Q) {
	if (Q->front == Q->rear) return (FALSE);
	LinkQueueNode* r;
	r = Q->front->next;
	printf("[");
	while (Q->rear != r) {
		printf("'%d',",r->data);
		r = r->next;
	}
	printf("'%d']",r->data);
}

void LinkQueueText() {
	LinkQueue* Q, Queue;
	QueueElementType* x, data;
	x = &data;
	Q = &Queue;
	InitQueue(Q);
	printf("——————————队列插入测试——————————\n");
	printf("请输入你要入队的数据,非数值结束：");
	while (1 == scanf_s("%d", x)) {
		EnterQueue(Q, data);
	}
	printf("\n队列里的数据为：");
	PrintLinkQueue(Q);
	printf("\n——————————队列出队测试——————————\n");
	DeleteQueue(Q, x);
	printf("出队元素为：%d\n", data);
	DeleteQueue(Q, x);
	printf("出队元素为：%d\n", data);
	printf("队列剩余元素为：");
	PrintLinkQueue(Q);
	printf("\n——————————队列取对头元素测试——————————\n");
	GetHead(Q, x);
	printf("第一次取对头元素为：%d\n", data);
	GetHead(Q, x);
	printf("第二次取对头元素为：%d\n", data);
	printf("队列剩余元素为：");
	PrintLinkQueue(Q);
	printf("\n——————————队列置空和队列是否为空测试——————————\n");
	printf("空为1，非空为0，队列置空前：%d\n", IsEmpty(Q));
	CleaQueue(Q);
	printf("空为1，非空为0，队列置空后：%d", IsEmpty(Q));
}

int main() {
	LinkQueueText();
}

10、测试结果

28c33a618b35484bb2bce18deb87d247.png

三、循环队列（顺序队列）的表示和实现 

1、循环队列结点结构

循环队列是队列的一种顺序表示和实现方法。与顺序栈类似，在队列的顺序存储结构中，用一组地址连续的存储单元依次存放从队头到队尾的位置是动态变化的因此需要附设俩个指针front和rear，分别指示队头元素和队尾元素在数组中的位置。

8feef4eea18d479bbdb2ef6f5d33ea45.png

typedef struct {
	QueueElementTye element[QueueMAXSIZE];
	int front;
	int rear;
}SeqQueue;

第三、四行：定义一个头结点一个尾节点，用于进和出。

 2、InitQueue初始化队列

/*初始化队列*/
void InitQueue(SeqQueue* Q) {
	Q->front = Q->rear = 0;
}

3、IsEmpty判断队列是否为空

/*队列判空*/
int IsEmpty(SeqQueue* Q) {
	if (Q->front == Q->rear) return TRUE;
	return FALSE;
}

4、IsFull队列判满

/*队列判满*/
int IsFull(SeqQueue* Q) {
	if ((Q->rear+1) % QueueMAXSIZE == Q->front) return TRUE;
	return FALSE;
}

因为判空是头尾相连的，故没法用这个判满 再次空出一个空间 用于判断。

5、EnterQueue队尾插入

/*队尾插入*/
int EnterQueue(SeqQueue* Q, QueueElementTye x) {
	if (IsFull(Q) == TRUE) return FALSE;
	Q->element[Q->rear] = x;
	Q->rear = (Q->rear+1)%QueueMAXSIZE;
	return TRUE;
}

6、DeleteQueue队头出队

/*队头出队*/
int DeleteQueue(SeqQueue* Q, QueueElementTye* x) {
	if (IsEmpty(Q) == TRUE) return FALSE;
	*x = Q->element[Q->front];
	Q->front = (Q->front + 1) % QueueMAXSIZE;
	return TRUE;
}

7、GetHead取队头元素

/*取队头元素*/
int GetHead(SeqQueue* Q,QueueElementTye* x) {
	if (IsEmpty(Q) == TRUE) return FALSE;
	*x = Q->element[Q->front];
	return TRUE;
}

 8、ClearQueue置空队列

/*置空队列*/
void ClearQueue(SeqQueue* Q) {
	memset(Q->element,NULL,sizeof(Q->element));
	Q->front = Q->rear = 0;
}

 9、循环队列的全套代码

#include <iostream>
#include <stdio.h>

#define QueueElementTye int
#define QueueMAXSIZE 5
#define TRUE 1
#define FALSE 0


typedef struct {
	QueueElementTye element[QueueMAXSIZE];
	int front;
	int rear;
}SeqQueue;

/*初始化队列*/
void InitQueue(SeqQueue* Q) {
	Q->front = Q->rear = 0;
}

/*队列判空*/
int IsEmpty(SeqQueue* Q) {
	if (Q->front == Q->rear) return TRUE;
	return FALSE;
}

/*队列判满*/
int IsFull(SeqQueue* Q) {
	if ((Q->rear+1) % QueueMAXSIZE == Q->front) return TRUE;
	return FALSE;
}

/*队尾插入*/
int EnterQueue(SeqQueue* Q, QueueElementTye x) {
	if (IsFull(Q) == TRUE) return FALSE;
	Q->element[Q->rear] = x;
	Q->rear = (Q->rear+1)%QueueMAXSIZE;
	return TRUE;
}

/*队头出队*/
int DeleteQueue(SeqQueue* Q, QueueElementTye* x) {
	if (IsEmpty(Q) == TRUE) return FALSE;
	*x = Q->element[Q->front];
	Q->front = (Q->front + 1) % QueueMAXSIZE;
	return TRUE;
}

/*取队头元素*/
int GetHead(SeqQueue* Q,QueueElementTye* x) {
	if (IsEmpty(Q) == TRUE) return FALSE;
	*x = Q->element[Q->front];
	return TRUE;
}

/*置空队列*/
void ClearQueue(SeqQueue* Q) {
	memset(Q->element,NULL,sizeof(Q->element));
	Q->front = Q->rear = 0;
}

/*打印队列内的数据*/
void PrintSeqQueue(SeqQueue* Q) {
	int i = Q->front, j = Q->rear;
	while (i != j) {
		printf("%d  ", Q->element[i]);
		i = (i + 1) % QueueMAXSIZE;
	}
	printf("\n");
}

void SeqQueueText() {
	SeqQueue* Q, Qu;
	int i;
	QueueElementTye* x, data;
	Q = &Qu;
	x = &data;
	InitQueue(Q);
	printf("1.入队，2.出队，3.查询整个队列，4.查询队头，5.置空队列，6.为满查询，7.为空查询，q结束。请输入你想执行的操作:");
	while (1 == scanf_s("%d", &i)) {
		if (i == 1) {
			printf("\n请输入你要入队的数据，非数字结束");
			scanf_s("%d", &data);
			EnterQueue(Q, data);
			printf("1.入队，2.出队，3.查询整个队列，4.查询队头，5.置空队列，6.为满查询，7.为空查询，q结束。请输入你想执行的操作:");
			continue;
		}
		if (i == 2) {
			DeleteQueue(Q, x);
			printf("出队的数据为：%d\n", data);
			printf("1.入队，2.出队，3.查询整个队列，4.查询队头，5.置空队列，6.为满查询，7.为空查询，q结束。请输入你想执行的操作:");
			continue;
		}
		if (i == 3) {
			PrintSeqQueue(Q);
			printf("1.入队，2.出队，3.查询整个队列，4.查询队头，5.置空队列，6.为满查询，7.为空查询，q结束。请输入你想执行的操作:");
			continue;
		}
		if (i == 4) {
			GetHead(Q, x);
			printf("队头的数据为：%d\n", data);
			printf("1.入队，2.出队，3.查询整个队列，4.查询队头，5.置空队列，6.为满查询，7.为空查询，q结束。请输入你想执行的操作:");
			continue;
		}
		if (i == 5) {
			ClearQueue(Q);
			printf("置空完成！\n");
			printf("1.入队，2.出队，3.查询整个队列，4.查询队头，5.置空队列，6.为满查询，7.为空查询，q结束。请输入你想执行的操作:");
			continue;
		}
		if (i == 6) {
			printf("满栈为1，非满为0：%d\n", IsFull(Q));
			printf("1.入队，2.出队，3.查询整个队列，4.查询队头，5.置空队列，6.为满查询，7.为空查询，q结束。请输入你想执行的操作:");
			continue;
		}
		if (i == 7) {
			printf("空栈为1，非空为0：%d\n", IsEmpty(Q));
			printf("1.入队，2.出队，3.查询整个队列，4.查询队头，5.置空队列，6.为满查询，7.为空查询，q结束。请输入你想执行的操作:");
			continue;
		}
	}
}

int main() {
	SeqQueueText();
}

10、循环队列运行结果：

892b20878626404cad5097a1713d7b91.png

Python数据结构与算法（3.5）——双端队列
盼小辉丶的博客
03-31 2万+
双端队列是另一个线性数据结构。虽然它也是一种受限线性表，但与栈和队列不同的是，双端队列的限制很少，它的基本操作也是线性表操作的子集，但从数据类型的角度来讲，它们与线性表又有着巨大的不同。本节将介绍双端队列的定义及其不同实现，并且给出双端队列的一些实际应用。
数据结构笔记——栈和队列
Mouguv的博客
11-07 715
栈和队列3.1 特殊线性表——栈3.1.1 栈的逻辑结构3.1.2 栈的顺序存储结构及实现两栈共享空间(双端栈)3.1.3 栈的链接存储结构及实现顺序栈和链栈的比较3.2 特殊线性表——队列3.2.1 队列的逻辑结构3.2.2 队列的顺序存储结构及实现3.2.3 队列的链接存储结构及实现循环队列和链队列的比较小结 3.1 特殊线性表——栈 3.1.1 栈的逻辑结构 栈：限定仅在表尾进行插入和删除操...
链式队列LinkQueue的实现
独行Freedom的博客
03-23 1925
和StaticStack类似，当数据元素为类类型，StaticQueue 的对象在创建时，会多次调用元素类型的构造函数，影响效率。需要实现链式队列。 队列的链式存储实现 设计要点 （1）类模板，抽象父类Queue的直接子类； （2）在内部使用链式结构实现元素的存储； （3） 只在链表的头部和尾部进行操作。 LinkQueue实现方式一（使用单链表LinkList） 代...
数据结构循环队列
le123didi的博客
10-07 569
循环队列可能有点难理解，可以去看看别人写的文章，我这里主要还是提供我的源码，附上一些图。
C语言 秒懂的队列操作
qq_41740162的博客
04-19 864
文章目录什么是队列队列定义常见的队列操作(C语言)``如果对你有所帮助,点个赞呗``队列的顺序存储结构结构体实现代码初始化入队出队获取队头元素全部代码文件结构Main函数头文件.C文件运行截图``换大家在评论区赐教,写写`` 什么是队列 通俗易懂的就是说一跟管道里的水流出来,里面的水分子就是一组队列先进先出(First In First Out)他和栈的操作类似,都是操作受限的的线性表 队列定义 ...
循环队列的基本函数操作
Robin's Log
10-14 3030
/***********************************************************************  REVISION LOG ENTRY  Revision By: http://blog.youkuaiyun.com/hongweijin  Revised on : 2004-10-14 18:05:29  Comments   : 循环队列的一般操作 ***
链表队列LinkQueue
最新发布
weixin_64031674的博客
03-28 192
4. 若指完后，head所指为NULL，则把尾指针也置空。1. 生成一个新节点newnode，指针置空。3. 通过free 释放temp指针所指。2. 头指针和尾指针都指向新节点。1.先定义一个新节点，指针置空。2. head指针指向下一个。1. 定义一个temp指针。
数据结构：第3章 限定性线性表—栈和队列.ppt
06-18
在本章中，我们将专注于两种特殊类型的线性数据结构——栈和队列，它们在逻辑上属于线性表，但在操作上具有特定的限制。 **栈（Stack）** 栈是一种“后进先出”（LIFO, Last In First Out）的数据结构，形象地比喻...
C语言——线性表及其应用（栈和队列）
悦悦的狗子
12-11 978
程序需求 初始化顺序栈 插入元素 删除栈顶元素 取栈顶元素 遍历顺序栈 置空顺序栈 初始化并建立链队列 入链队列 出链队列 遍历链队列 算法的基本思想 使用栈和队列的表示方式 1.栈作为一种限定性线性表，将线性表的插入与删除操作限制为只在表的一端进行；使用顺序存储结构，利用一组地址连续的存储单元，设置栈顶指针Top来动态的指示栈顶元素在顺序栈中的位置，Top=-1表示空栈； 2.队列只允许在表的...
数据结构学习之路————栈和队列
zhenghao_zh45的博客
07-26 902
       栈和队列是两种重要的线性结构。从数据结构的角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表基本操作的子集。，它们是操作受限的线性表，因此可称为限定性的数据结构。 1.栈        栈是限定仅在表尾进行插入或删除操作的线性表。因此对栈来说，表尾端有其特殊含义，称为栈顶，表头端称为栈底。不含元素的空表称为空栈。栈顶实现元素的进出，栈的修改遵循后进先出的原则。因此...
C语言 详解链式存储队列
qq_41740162的博客
04-21 451
文章目录链式存储队列实现代码 链式存储队列 什么使链式存储队列呢?说白了就是一个受到操作限制的链表,只能在链表的头结点进行删除结点,也只能在链表的尾结点进行插入结点,且不能在中间进行插入删除操作,你以为限制到此就结束了吗?但还差一样东西哦,它比不同的链表多了一个游标指针,且分别命名为头指针,尾指针如图: 实现代码 ...
数据结构与算法基础-学习-13-线性表之链队
qq_45111959的博客
02-22 673
介绍链队的结构体定义和初始化链队、获取链队长度、获取链队头元素、链队入队、链队出队等用途、源码、参数解释。
c语言 initqueue头文件,队列和栈相关总结
weixin_42310348的博客
05-25 3115
一、链栈相关的操作，注意出栈的时候要考虑空栈和栈只有一个元素的情况；入栈则要考虑空栈。1.头文件#ifndef LINKSTACK_H#define LINKSTACK_Htypedef struct{Linklist top,base;}Linkstack;void InitStack(Linkstack &l);//初始化栈Status Push(Linkstack &l,el...
C++ 数据结构之--队列（array_queue和link_queue）
who_I_am__的博客
10-22 350
队列可以看作是一种特殊的列表，只允许在表的一端（称为队尾）进行插入操作（称为入队），而在另一端（称为队头）进行删除操作（称为出队）。这导致了访问队列中间元素的效率较低，时间复杂度为 O(n)，其中 n 是队列中元素的数量。需要额外的空间：链表实现的队列除了存储元素值之外，还需要额外的指针来连接节点。高效的插入和删除：链表实现的队列在头部和尾部插入、删除元素的操作上具有高效性。动态扩容：链表实现的队列在插入元素时可以动态地分配内存，避免了数组实现的队列需要预先指定固定大小的问题。类是一个模板类，具有一个。
链式队列（Linked Queue)
Sun.ME的博客
02-16 1377
链式队列（Linked Queue、Queue、队列
LinkQueue
gaozigeng的博客
07-15 243
链式队列
数据结构-链队linkQueue
caixiaoniao9527的博客
07-30 556
时间：2018/07/30下午14:57 测试环境：code::blocks 测试代码： #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef int ElemType; typedef struct linkQueueNode{ ElemType data; struct linkQueueNode *nex...
链式队列的实现
程序猿的挨踢人生
03-06 1374
队列是一种先进先出的线性表，也是一种操作受限的线性表，只允许在表的头部删除元素和尾部添加元素。队列有链式表示和顺序表示。队列的链式表示由于在表头和表尾操作，需要两个指针分别指向对头和队尾。空的链式队列判决条件为对头指针和队尾指针是否指向同一个结点（头节点）。 链式队列的存储结构 #define OK 1 #define NULL_QUEUE 0 #define ERROR
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值