【初阶数据结构篇】队列的实现（赋源码）

文章目录

• 队列
• • [1 代码位置](#1 代码位置)
  • [2 概念与结构](#2 概念与结构)
  • • 1.1概念
    • 1.2结构
  • [2 队列的实现](#2 队列的实现)
  • • [2.1 队列的初始化和销毁](#2.1 队列的初始化和销毁)
    • • [2.1.1 初始化](#2.1.1 初始化)
      • [2.1.2 销毁](#2.1.2 销毁)
    • [2.2 队列插入和删除数据](#2.2 队列插入和删除数据)
    • • [2.2.1 队尾插入数据（入队列）](#2.2.1 队尾插入数据（入队列）)
      • [2.2.2 队头删除数据（出队列）](#2.2.2 队头删除数据（出队列）)
    • [2.3 返回队头/队尾数据](#2.3 返回队头/队尾数据)
    • [2.4 返回队列的有效数据个数](#2.4 返回队列的有效数据个数)

队列

1 代码位置

gitee\]([Queue/Queue · petrichor/2024-summer-c-language - 码云 - 开源中国 (gitee.com)](https://gitee.com/petrichor2024/2024-summer-c-language/tree/master/Queue/Queue)) ### 2 概念与结构 #### 1.1概念 ​ **只允许** 在⼀端进行插⼊数据操作，在另⼀端进行删除数据操作的特殊线性表，队列具有先进先出**FIFO(First In First Out)** ​ **⼊队列：进⾏插⼊操作的⼀端称为队尾** ​ **出队列：进⾏删除操作的⼀端称为队头**  #### 1.2结构 > 队列也可以数组和链表的结构实现，使⽤链表的结构实现更优⼀些，因为如果使⽤数组的结构，出队列在数组头上出数据，效率会⽐较低。 > > \*\*数组头删时间复杂度：O(N) \*\* **数组尾插时间复杂度：O(1)** > > **单链表头删时间复杂度：O(1)** **单链表尾插时间复杂度：O(N)** * 乍一看二者难分伯仲，但如果我们在单链表的结构里再定义一个指向尾结点的指针，那么单链表就可以实现O(1)的尾插时间复杂度，而数组没有什么特别好的办法实现这种转变。  *** ** * ** *** ### 2 队列的实现 **Queue.h** ```c #pragma once #include #include #include #include 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*); ``` *** ** * ** *** **test.c** * 用来测试我们写的函数(函数的调用) * 这一部分就是自己写的时候用的测试用例，随便什么都行 最好是写一个方法测试一次，不然找错误的时候会很痛苦😜 ```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; } ``` *** ** * ** *** Queue.c **函数方法的实现，重点重点！！！** 在每一个方法的第一排都使用assert宏来判断形参是否为空（避免使用时传入空指针，后续解引用都会报错） #### 2.1 队列的初始化和销毁 ##### 2.1.1 初始化 * 前面提到，我们在定义队列时，一个结构体用来定义队列，其中有指向队列头尾的指针（其中还有一个size，用来保存链表长度，后面会讲到为什么），另一个就是队列结点的结构，和单链表一样 ```c #define _CRT_SECURE_NO_WARNINGS 1 #include "Queue.h" void QueueInit(Q* pq) { assert(pq); pq->phead = pq->ptail = NULL; pq->size = 0; } ``` * 和单链表一样，初始化只需让指向队列的指针置为空即可，只不过这里多了一个尾指针，同时队列为空，size=0 * 链表空间都是按需申请，所以入数据都是通过之后的插入方法一个一个实现的 ##### 2.1.2 销毁 ```c 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; } ``` 同单链表 *** ** * ** *** #### 2.2 队列插入和删除数据 ##### 2.2.1 队尾插入数据（入队列） 同样的我们先写一个申请结点空间的函数 ```c 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++ ```c 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++; } ``` ##### 2.2.2 队头删除数据（出队列） 删除数据的时候一定要判断队列是否为空!（也可以通过size来判断） ```c bool QueueEmpty(Q* pq) { assert(pq); return pq->phead == NULL && pq->ptail == NULL; } ``` * 根据队列结点个数是否大于一个分两种情况讨论 * 别忘了size-- ```c 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--; } ``` *** ** * ** *** #### 2.3 返回队头/队尾数据 ```c 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; } ``` *** ** * ** *** #### 2.4 返回队列的有效数据个数 * **size作用** * 首先队列和栈一样，不能进行遍历和随机访问，必须将队头出数据才能访问下一个，这样遍历求个数是不规范的 * 其次时间复杂度O(N)，程序效率低 所以我们在队列结构里多定义了一个size，很好地解决了这个问题 ```c 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; } ``` *** ** * ** *** Queue.c(完整版) ```c #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; } ``` **对于队列这一种结构的实现，因为和单链表差异也不大，更细节的内容就没有过多赘述，对以单链表的实现方法有什么疑问的话，推荐先去看这一篇哦-\>** [单链表的实现方法](http://t.csdnimg.cn/pnBt7) 以上就是队列的实现方法啦，各位大佬有什么问题欢迎在评论区指正，您的支持是我创作的最大动力！❤️