队列的链式结构(C语言实现)

最新推荐文章于 2024-09-13 10:21:40 发布
最新推荐文章于 2024-09-13 10:21:40 发布
阅读量149 收藏
点赞数
分类专栏： 数据结构详解 文章标签： c语言 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haijv/article/details/129942465
版权

5.2 队列的链式结构


文章目录



5.2.1 队列链式结构简介



相比较与循环队列的顺序存储结构，链式结构多了一条指向下一结点的链，和单链表结构是类似的，只是链式队列只能"头出尾进"，下图是一个链式队列的简单结构图：

在这里插入图片描述


引入了一个头结点不存储任何东西，front指针指向头结点，rear指针指向队列的最后一个元素。


下面是涉及到有关链式队列操作的表：

操作函数操作结果
InitQueue(LinkQueue *Q)初始化链队列
DestroyQueue(LinkQueue *Q)销毁队列
ClearQueue(LinkQueue *Q)清空队列
QueueEmpty(LinkQueue Q)判断队列是否为空
QueueLength(LinkQueue Q)求链队列长度
GetHead(LinkQueue Q,QElemType *e)获取头元素，并且存入指针e
EnQueue(LinkQueue *Q,QElemType e)入队
DeQueue(LinkQueue *Q,QElemType *e)出队
QueueTraverse(LinkQueue Q)遍历并且打印队列



5.2.2 队列链式结构定义

链队列的结构定义和单链表类似，一个链式队列包含数个结点和指向头结点，尾结点的指针(front和rear)，一个结点包含存储的数据data和指向下一结点的链next。

代码如下：

typedef struct QNode{           //结点结构
    QElemType data;
    struct QNode *next;  
}QNode,*QueuePtr;

typedef struct{                 //队列结构
    QueuePtr front,rear;       //队头 队尾指针
}LinkQueue;



QNode为结点类，LinkQueue为链队列类，队头，队尾指针都是结点指针类型。




5.2.3 初始化链队列



一个初始的链队列中不存储任何数据，头尾指针都指向头结点，下图是一个初始化的链队列：

在这里插入图片描述

千万要注意：头结点不等于队头，头结点不存储任何数据，队头是头结点的下一结点，即Q->front->next。

代码如下：

/*初始化链队列*/
/*Q->front 是头结点不存任何东西 Q->front->next表示队头*/
Status InitQueue(LinkQueue *Q){
    Q->front=Q->rear=(QueuePtr)malloc(sizeof(QNode));
    if(!Q->front)
        exit(OVERFLOW);
    Q->front->next = NULL;
    return OK;
}




5.2.4 销毁队列和清空队列

销毁队列和清空队列是不同的，销毁队列连同头结点(那个不存储数据的结点)，一起删除。而清空队列不删除头结点，只是删除存储数据的结点。


1. 销毁队列

代码如下：

/*销毁队列*/
Status DestroyQueue(LinkQueue *Q){
    /*从头结点开始一直删除到最后 直到链队列不存在为止*/
    while(Q->front){
        Q->rear = Q->front->next;
        free(Q->front);
        Q->front = Q->rear;
    }
    return OK;
}



其中的Q->rear只是起到一个暂时记录Q->front->next结点的作用。第一次循环：Q->rear 记录了队头的位置，然后free(Q->front)释放头结点，最后将头指针指向队头的位置(头结点的下一位置)。随后的循环都以这样的形式进行，从头结点开始删除，直到队列不存在为止。

2. 清空队列



代码如下：

/*清空队列*/
Status ClearQueue(LinkQueue *Q){
    QueuePtr p,q;
    Q->rear = Q->front;
    p = Q->front->next;
    Q->front->next = NULL;
    /*上面头尾结点都指向null 最后再将队列中间的结点一个个释放*/
    while(p){
        q=p;
        p=p->next;
        free(q);
    }

    return OK;
}



清空队列，首先将尾指针指向头结点位置Q-rear = Q->front，然后将队头元素赋值给指针p，即p = Q->front->next，然后再将头结点的next指针赋值为空，这就让头尾结点都变成了初始化的时候，但是中间还有很多队列结点等待释放，这便交给了下面的while循环。




5.2.5 判断链队列是否为空和获取链队列长度


1. 判断链队列是否为空

当头指针和尾指针在同一个位置时，链队列为空，代码如下：

/*判断队列是否为空*/
Status QueueEmpty(LinkQueue Q){ 
	if(Q.front==Q.rear)
		return TRUE;
	else
		return FALSE;
}


2. 获取链队列长度

先使p=Q.front，让p指向头结点，只要Q.rear!=p就使p一直往下移动，并且让i+1，记录长度。

代码如下：

/*求队列长度*/
int QueueLength(LinkQueue Q){
    int i = 0;
    QueuePtr p;
    p = Q.front;
    while(Q.rear!=p){
        i++;
        p=p->next;
    }
    return i;
}




5.2.6 获得链队列队头元素

只要通过头指针就可以轻易获取到队列头元素，代码如下：

/*获取头元素*/
Status GetHead(LinkQueue Q,QElemType *e){
    QueuePtr p;
    if(Q.front==Q.rear)       //队空
        return ERROR;
    p = Q.front->next;
    *e = p->data;
    return OK;
}




5.2.7 入队和出队


1. 入队

链队列入队和单链表的插入是类似的，只不过链队列只能从队尾插入，入队的示意图如下：

在这里插入图片描述

步骤如下：

  • 先生成一个新结点s，并且将数据存入
  • 然后让s结点的next指针指向NULL，即s->next=NULL
  • 再让rear指针处结点的next指针指向s，即Q->rear->next = s
  • 最后将rear指针移动到结点s处Q->rear = s，完成入队

代码如下：

/*链队列入队*/
Status EnQueue(LinkQueue *Q,QElemType e){
    QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
    if(!s)
        exit(OVERFLOW);
    s->data = e;
    s->next = NULL;
    Q->rear->next = s;      //将s赋值给队尾后继元素
    Q->rear = s;            //最后将s赋值给队尾指针

    return OK;
}


2. 出队

出队都是在队头完成的，下面是出队示意图：

在这里插入图片描述

步骤如下：

  • 首先判断队列是否为空
  • 将要出队的队头赋值给p，即p=Q->front->next
  • 然后再将p的后继变成队头，即Q->front->next = p->next
  • 释放结点p

注意，如果删除的队头就是队尾结点，将rear指向头结点。

代码如下：

/*链队列出队*/
Status DeQueue(LinkQueue *Q,QElemType *e){
    QueuePtr p;
    if(Q->front == Q->rear)     //队空
        return ERROR;
    p = Q->front->next;         //将队头将要删除的元素暂时储存在p
    *e = p->data;
    Q->front->next = p->next;   //将p的后继变为队头，之前的队头出队
    if(Q->rear == p)        //若删除的队头就是队尾，将rear指向头结点
        Q->rear = Q->front;
    free(p);
    return OK;
}




5.2.8 遍历打印链队列

代码如下：

/*遍历队列 从队头开始到队尾*/
Status visit(QElemType c){
    printf("%d ",c);
    return OK;
}

Status QueueTraverse(LinkQueue Q){
    QueuePtr p;
    p = Q.front->next;      //p是队头
    while(p){
        visit(p->data);
        p = p->next;
    }
    printf("\n");
    return OK;
}




5.2.9 测试代码

测试代码

int main(){
	int i;
	QElemType d;
	LinkQueue q;
	i=InitQueue(&q);
	if(i)
		printf("成功地构造了一个空队列!\n");
	printf("是否空队列？%d(1:空 0:否)  ",QueueEmpty(q));
	printf("队列的长度为%d\n",QueueLength(q));
	EnQueue(&q,-5);
	EnQueue(&q,5);
	EnQueue(&q,10);
	printf("插入3个元素(-5,5,10)后,队列的长度为%d\n",QueueLength(q));
	printf("是否空队列？%d(1:空 0:否)  ",QueueEmpty(q));
	printf("队列的元素依次为：");
	QueueTraverse(q);
	i=GetHead(q,&d);
	if(i==OK)
	 printf("队头元素是：%d\n",d);
	DeQueue(&q,&d);
	printf("删除了队头元素%d\n",d);
	i=GetHead(q,&d);
	if(i==OK)
		printf("新的队头元素是：%d\n",d);
	ClearQueue(&q);
	printf("清空队列后,q.front=%u q.rear=%u q.front->next=%u\n",q.front,q.rear,q.front->next);
	DestroyQueue(&q);
	printf("销毁队列后,q.front=%u q.rear=%u\n",q.front, q.rear);
	system("pause");
	return 0;
}


运行结果

成功地构造了一个空队列!
是否空队列？1(1:空 0:否)  队列的长度为0
插入3个元素(-5,5,10)后,队列的长度为3
是否空队列？0(1:空 0:否)  队列的元素依次为：-5 5 10
队头元素是：-5
删除了队头元素-5
新的队头元素是：5
清空队列后,q.front=13060336 q.rear=13060336 q.front->next=0
销毁队列后,q.front=0 q.rear=0
请按任意键继续. . .




5.2.10 完整代码

下面附上完整代码：

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20

typedef int Status; 
typedef int QElemType;

typedef struct QNode{           //结点结构
    QElemType data;
    struct QNode *next;  
}QNode,*QueuePtr;

typedef struct{                 //队列结构
    QueuePtr front,rear;       //队头 队尾指针
}LinkQueue;

/*初始化链队列*/
/*Q->front 是头结点不存任何东西 Q->front->next表示队头*/
Status InitQueue(LinkQueue *Q){
    Q->front=Q->rear=(QueuePtr)malloc(sizeof(QNode));
    if(!Q->front)
        exit(OVERFLOW);
    Q->front->next = NULL;
    return OK;
}

/*销毁队列*/
Status DestroyQueue(LinkQueue *Q){
    /*从头结点开始一直删除到最后 直到链队列不存在为止*/
    while(Q->front){
        Q->rear = Q->front->next;
        free(Q->front);
        Q->front = Q->rear;
    }
    return OK;
}

/*清空队列*/
Status ClearQueue(LinkQueue *Q){
    QueuePtr p,q;
    Q->rear = Q->front;
    p = Q->front->next;
    Q->front->next = NULL;
    /*上面头尾结点都指向null 最后再将队列中间的结点一个个释放*/
    while(p){
        q=p;
        p=p->next;
        free(q);
    }

    return OK;
}

/*判断队列是否为空*/
Status QueueEmpty(LinkQueue Q){ 
	if(Q.front==Q.rear)
		return TRUE;
	else
		return FALSE;
}


/*求队列长度*/
int QueueLength(LinkQueue Q){
    int i = 0;
    QueuePtr p;
    p = Q.front;
    while(Q.rear!=p){
        i++;
        p=p->next;
    }
    return i;
}

/*获取头元素*/
Status GetHead(LinkQueue Q,QElemType *e){
    QueuePtr p;
    if(Q.front==Q.rear)       //队空
        return ERROR;
    p = Q.front->next;
    *e = p->data;
    return OK;
}

/*链队列入队*/
Status EnQueue(LinkQueue *Q,QElemType e){
    QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
    if(!s)
        exit(OVERFLOW);
    s->data = e;
    s->next = NULL;
    Q->rear->next = s;      //将s赋值给队尾后继元素
    Q->rear = s;            //最后将s赋值给队尾指针

    return OK;
}

/*链队列出队*/
Status DeQueue(LinkQueue *Q,QElemType *e){
    QueuePtr p;
    if(Q->front == Q->rear)     //队空
        return ERROR;
    p = Q->front->next;         //将队头将要删除的元素暂时储存在p
    *e = p->data;
    Q->front->next = p->next;   //将p的后继变为队头，之前的队头出队
    if(Q->rear == p)        //若删除的队头就是队尾，将rear指向头结点
        Q->rear = Q->front;
    free(p);
    return OK;
}

/*遍历队列 从队头开始到队尾*/
Status visit(QElemType c){
    printf("%d ",c);
    return OK;
}

Status QueueTraverse(LinkQueue Q){
    QueuePtr p;
    p = Q.front->next;      //p是队头
    while(p){
        visit(p->data);
        p = p->next;
    }
    printf("\n");
    return OK;
}

int main(){
	int i;
	QElemType d;
	LinkQueue q;
	i=InitQueue(&q);
	if(i)
		printf("成功地构造了一个空队列!\n");
	printf("是否空队列？%d(1:空 0:否)  ",QueueEmpty(q));
	printf("队列的长度为%d\n",QueueLength(q));
	EnQueue(&q,-5);
	EnQueue(&q,5);
	EnQueue(&q,10);
	printf("插入3个元素(-5,5,10)后,队列的长度为%d\n",QueueLength(q));
	printf("是否空队列？%d(1:空 0:否)  ",QueueEmpty(q));
	printf("队列的元素依次为：");
	QueueTraverse(q);
	i=GetHead(q,&d);
	if(i==OK)
	 printf("队头元素是：%d\n",d);
	DeQueue(&q,&d);
	printf("删除了队头元素%d\n",d);
	i=GetHead(q,&d);
	if(i==OK)
		printf("新的队头元素是：%d\n",d);
	ClearQueue(&q);
	printf("清空队列后,q.front=%u q.rear=%u q.front->next=%u\n",q.front,q.rear,q.front->next);
	DestroyQueue(&q);
	printf("销毁队列后,q.front=%u q.rear=%u\n",q.front, q.rear);
	system("pause");
	return 0;
}
压力小子呀
关注
专栏目录
队列的链式存储C语言实现
04-04
以上就是用C语言实现队列链式存储的基本操作。这种实现方式具有灵活的内存管理和高效的插入与删除性能，尤其适用于大数据环境。通过这些基本操作，可以构建更复杂的数据处理系统，例如任务调度、消息传递等。在实际...
C语言实现队列源码，包含顺序队列，链式队列，循环队列，亲测可用
04-25
本文将详细讨论在C语言中实现的几种队列类型，包括顺序队列、链式队列以及循环队列，并结合提供的源代码进行解析。 顺序队列是基于数组实现的数据结构，它的特点是操作主要集中在数组的两端：一端称为队头，用于出...
链式队列实现(c语言)
lixin203171613的博客
11-27 1495
队列是一个线性的数据结构，这个数据结构只从一端进行插入，另一端进行删除，禁止直接访问除这两端以外的一切数据。如图所示，队列就像一个管道一样，从一端输入，一端输出，先输入的就先输出。
c语言实现链式队列
u014574317的博客
03-31 732
就是要注意下，有个结点是特殊的，那就是队列结点，一个是要指向链表的第一个结点，一个是要指向链表的第二个结点。元素类型是跟其他普通链表结点一样的。 #include #include typedef struct Node *node; typedef struct QNode *Queue; struct Node{ int data; struct Node *next; };
C语言队列的实现（链式队列）
m0_74892619的博客
04-04 87
简单的队列实现
数据结构之链式队列（C语言版）
zhu134的博客
05-16 222
如果分配成功后就让队首指针的下一个结点指向NULL（即头结点指向NULL）最后判断原队列是否只有一个结点（即判断队尾指针是否指向待删除的结点）再定义一个linkequeue结构体其中包含队头指针和队尾指针。之后再将结点的地址赋给队尾指针（即结点s变成了新的队尾）之后判空（即队首指针的头结点所指向的结点是否为空）如果是则要让队尾指针指向队首指针所指向的头结点。先定义一个链式队列结点（以链表结点形式实现）创建结点p并且将队首指针的头结点指向结点p。再创建一个结点s将数据写入结点。之后再让队尾指针指向结点s。
C语言队列实现：链式队列
m0_53881899的博客
03-09 128
链式队列
C语言实现链式队列
weixin_42937740的博客
03-11 732
链式队列（Linked Queue）是一种基于链表实现的队列数据结构。本文我们就分模块实现一下，然后编写一个测试代码进行测试
顺序存储和链式存储的泛型队列_C语言项目
04-12
总之，本项目通过C语言实现了顺序存储和链式存储的泛型队列，提供了一套完整的队列操作接口，适用于多种场景。理解和掌握这些知识点对于提升C语言编程能力和数据结构应用能力非常有帮助。通过阅读和分析项目中的代码...
链式队列的C语言实现附上注释
07-24
链式队列的C语言实现附上注释
队列的链式表示和实现（C语言）
qq_73884528的博客
03-27 810
队列（Queue）是一种基本的数据结构，它可以存储一系列元素，并支持在队尾添加元素，在队首移除元素，遵循先进先出（FIFO）的原则。链表队列是一种基于链表实现的队列，它可以更好地适应动态添加和删除元素的情况，并且不需要事先指定队列大小。链表队列在计算机科学中有着广泛的应用，例如网络编程中的请求调度，操作系统中的进程调度等。
数据结构学习 链式队列的C语言实现
weixin_42530925的博客
04-10 65
头结点总是指向队首元素，执行三次入队操作后，队首元素值为21，队尾元素值为24。执行一次出队操作后，原先的队首元素21出队，头结点指向新的队首22，得到出队元素的值value为21。函数实现LinkQueue.c。头文件LinkQueue.h。测试函数test.c。
数据结构 | 链式队列
鷾
05-24 123
链式队列基本操作，包括初始化、判断队列是否为空、入队、出队的C语言实现
51.【C语言】字符函数和字符串函数(strcpy函数)
最新发布
2401_85828611的博客
09-13 559
讲解strcpy函数的简单使用 模拟实现 自制代码优化
数据结构应用实例(四)——最小生成树
Blogs of zcy1221
09-10 1217
每次选择最近顶点，需要进行一次遍历，比较 N 次，之后将其添加进最小生成树，更新 weight 和 pre，一次遍历，N 次操作，总共需要选择 N-1 次，所以 prim 算法的时间复杂度为。4、 kruskal 算法，为图的结构体添加成员 E ——存放边的结构体数组，成员为两节点编号和边的权值，这样在创建图时，可以直接创建 E，同时，图的数据文件中添加边的条数；综合所述，Prim 算法适合顶点相对较少而边相对稠密的网的最小生成树的求解，而 Kruskal 算法适合于求边比较稀疏的网的最小生成树；
【数据结构-二维前缀最小值】力扣3148. 矩阵中的最大得分
sjsjs11的博客
09-11 1004
也就是说，当grid[i][j]为终点的时候，要在以(0,0)为左上角，(i,j)为右下角的矩阵中（不包括(i,j)）找到最小的那个元素值mn。如果用列来表示我们需要的信息，也就是从0到j-1列的最小值，然后第j列的从0到i-1行的最小值，这两个最小值我们进行比较，更小的那个就是我们需要的信息。所以说在遍历每一行的时候，我们都要重置pre_min为INT_MAX，pre_min的作用就是找到从0到j-1列的最小值，col_min的作用就是储存第j列的从0到i-1行的最小值。
数据结构----树
2301_77841194的博客
09-07 995
1、树(Tree)是n(n≥0)个结点的有限集。n=O时称为空树。在任意一棵非空树中:(1）有且仅有一个特定的称为根(Root)的结点;(2)当n>1时,其余结点可分为m(m>0)个互不相交的有限集T1、T2、……、Tm,其中每一个集合本身又是一棵树,并且称为根的子树(SubTree)2、树的结点包含一个数据元素及若干指向其子树的分支。结点拥有的子树数称为结点的度(Degree)。度为0的结点称为叶结点（Leaf）或终端结点;度不为0的结点称为非终端结点或分支结点。
数据结构归并两个链表并按照学号升序
wsdsbtzk的博客
09-07 368
int id;int score;int N,M;cin>>N>>M;return 0;i<n;i++)Student* q;while(p!=NULL)q=p;p=p->next;free(q);=NULL)p=p->next;p->next=s2;=NULL)
Java-数据结构-栈和队列-Stack和Queue (oﾟ▽ﾟ)o
2303_80388948的博客
09-07 920
栈：是一种特殊的线性表，其 只允需在固定的一端进行插入和删除操作。 进行插入和删除的一端叫做栈顶，另一端叫做栈底。并且要遵循 先进后出 的规则。 队列：是一种只允许一端进行插入元素，在另一端进行删除元素的特殊的线性表。 队列具有 先进先出 的性质：进行插入的一端叫做队尾，进行删除的一端叫做队头。也就是队尾进，队头出。
C语言实现与应用：队列的顺序和链式存储
在这个实验中，主要探讨了两种队列的实现方式：顺序存储和链式存储，并且针对这两种存储结构，实现了队列的基本操作，如初始化、判断队满和队空、入队、出队以及数据的显示。 对于顺序存储队列，通常使用数组来实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

压力小子呀

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

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

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

打赏作者

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

抵扣说明：

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

余额充值