用链表模拟实现队列（FIFO）
个人主页：欢迎大家光临——>沙漠下的胡杨
各位大帅哥，大漂亮
如果觉得文章对自己有帮助
可以一键三连支持博主
你的每一分关心都是我坚持的动力
☄： 本期重点：用链表实现队列
希望大家每天都心情愉悦的学习工作。
目录
队列的概念和结构：
链式队列的实现：
头文件篇：
函数接口实现篇（源文件篇）
队列的初始化：
队列的销毁：
队列的插入：
队列的删除：
取出队列的首尾元素：
判断队列是否为空：
返回队列中的元素个数：
整体文件：
头文件篇：
源文件篇：
循环队列习题———>力扣622 设计循环队列
题目分析：
代码实现：
循环器的构造：
循环器的初始化：
循环器的销毁：
判断循环器是否为空，是否满了：
循环器的插入：
循环队列的删除：
取循环器队列头部数据：
取循环器队列尾部数据：
整体题解：
模数据 版题解：
控制边界的题解：
队列的概念和结构：
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out)
入队列：进行插入操作的一端称为队尾
出队列：进行删除操作的一端称为队头
示意图如下：
我们在队列的实现方面，可以用数组和链表共同实现，但是如果用数组实现的话，我们在头部出数据时要移动数据，不太方面并且有扩容空间浪费，所以我们采用链表实现队列。链式结构不用考虑数据的挪动和扩容问题。
链式队列的实现：
头文件篇：
首先我们通过队列的性质可以知道，要完成先进先出的性质，我们需要一个结构体包含着一个头结点，一个尾节点，方便我们进行如队列和出队列，并且可以使我们不用二级指针就可以完成相对应的操作。另外我们还要创建一个链表的结点，存放数据，结构如下：
typedef int QDataType; typedef struct QueueNode//链表 { QDataType data; struct QueueNode* next; }QNode; typedef struct Queue//队列 { QNode* head; QNode* tail; }Queue;剩下的就是函数接口，包括了初始化，销毁，插入，删除，取队列首元素，取尾元素，判断队列是否为空，返回队列元素个数。
void QueueInit(Queue* qp);//初始化 void QueueDestroy(Queue* qp);//队列的销毁 void QueuePush(Queue* qp,QDataType x);//队列插入 void QueuePop(Queue* qp);//队列删除 QDataType QueueFront(Queue* qp);//取出队列首元素 QDataType QueueBack(Queue* qp);//取出队列末尾元素 bool QueueEmpty(Queue* qp);//判断队列是否为空 int QueueSize(Queue* qp);//返回队列的元素个数下面我们进入实现部分。
函数接口实现篇（源文件篇）
队列的初始化：
void QueueInit(Queue* qp)//初始化 { assert(qp); qp->head = qp->tail = NULL; }首先判断是否为空，然后把头尾都置为NULL。
队列的销毁：
void QueueDestroy(Queue* qp)//队列的销毁 { assert(qp); QNode* cur = qp->head; while (cur) { QNode* next = cur->next; free(cur); cur = next; } qp->head = qp->tail = NULL; }我们先创建一个链表的结点用于遍历，然后在free前，先创建一个新的链表指针，用于保存下一个结点，否则 free 这个节点之后就找不到下一个结点啦，最后就是把队列的头结点和尾节点都置为NULL。（千万记住是创建的是链表的指针，不要创建为队列的指针）。
队列的插入：
void QueuePush(Queue* qp,QDataType x)//队列插入 { assert(qp); QNode *newnode = (QNode*)malloc(sizeof(QNode)); if (newnode == NULL) { perror("malloc fail\n"); exit(-1); } newnode->next = NULL; newnode->data = x; if (qp->head == NULL) { qp->head = qp->tail = newnode; } else { qp->tail->next = newnode; qp->tail = newnode; } }插入时我们要先创建结点（链表的结点），然后分为两种情况，首先是队列为空时，我们应该把头指针和尾指针都赋值为新节点的值。如果不为空时，我们应该把新节点连接到尾指针处，然后更新尾节点。
队列的删除：
void QueuePop(Queue* qp)//队列删除 { assert(qp); assert(!QueueEmpty(qp)); if (qp->head->next == NULL) { qp->head = qp->tail = NULL; } else { QNode* next = qp->head->next; free(qp->head); qp->head = next; } }我们删除时，先判断队列是否为空，不为空在进行删除，删除前，我们要创建链表的指针存放头指针下一个，接着 free掉头指针，然后更新头指针。
取出队列的首尾元素：
QDataType QueueFront(Queue* qp)//取出队列首元素 { assert(qp); assert(!QueueEmpty(qp)); return qp->head->data; } QDataType QueueBack(Queue* qp)//取出队列末尾元素 { assert(qp); assert(!QueueEmpty(qp)); return qp->tail->data; }首尾元素大致都一样，我们都先要判断是否为空，在进行取值。
判断队列是否为空：
bool QueueEmpty(Queue* qp)//判断队列是否为空 { assert(qp); return qp->head == NULL; }如果队列为空时，我们的 qp->head 和qp->tail 都为NULL，我们使用表达式判断就可以啦。
返回队列中的元素个数：
int QueueSize(Queue* qp)//返回队列的元素 { assert(qp); int size = 0; QNode* cur = qp->head; while (cur) { ++size; cur = cur->next; } return size; }我们创建一个size值作为计数器，然后一个个进行遍历就好了。
关于函数的接口就已经写好了，注意一点就是我们创建的有链表，和队列这两个结构体，千万不要创建错了。
整体文件：
头文件篇：
#pragma once #define _CRT_SECURE_NO_WARNINGS #include#include #include #include typedef int QDataType; typedef struct QueueNode { QDataType data; struct QueueNode* next; }QNode; typedef struct Queue { QNode* head; QNode* tail; }Queue; void QueueInit(Queue* qp);//初始化 void QueueDestroy(Queue* qp);//队列的销毁 void QueuePush(Queue* qp,QDataType x);//队列插入 void QueuePop(Queue* qp);//队列删除 QDataType QueueFront(Queue* qp);//取出队列首元素 QDataType QueueBack(Queue* qp);//取出队列末尾元素 bool QueueEmpty(Queue* qp);//判断队列是否为空 int QueueSize(Queue* qp);//返回队列的元素个数 源文件篇：
#include "Queue.h" void QueueInit(Queue* qp)//初始化 { assert(qp); qp->head = qp->tail = NULL; } void QueueDestroy(Queue* qp)//队列的销毁 { assert(qp); QNode* cur = qp->head; while (cur) { QNode* next = cur->next; free(cur); cur = next; } qp->head = qp->tail = NULL; } void QueuePush(Queue* qp,QDataType x)//队列插入 { assert(qp); QNode *newnode = (QNode*)malloc(sizeof(QNode)); if (newnode == NULL) { perror("malloc fail\n"); exit(-1); } newnode->next = NULL; newnode->data = x; if (qp->head == NULL) { qp->head = qp->tail = newnode; } else { qp->tail->next = newnode; qp->tail = newnode; } } void QueuePop(Queue* qp)//队列删除 { assert(qp); assert(!QueueEmpty(qp)); if (qp->head->next == NULL) { qp->head = qp->tail = NULL; } else { QNode* next = qp->head->next; free(qp->head); qp->head = next; } } QDataType QueueFront(Queue* qp)//取出队列首元素 { assert(qp); assert(!QueueEmpty(qp)); return qp->head->data; } QDataType QueueBack(Queue* qp)//取出队列末尾元素 { assert(qp); assert(!QueueEmpty(qp)); return qp->tail->data; } bool QueueEmpty(Queue* qp)//判断队列是否为空 { assert(qp); return qp->head == NULL; } int QueueSize(Queue* qp)//返回队列的元素 { assert(qp); int size = 0; QNode* cur = qp->head; while (cur) { ++size; cur = cur->next; } return size; }
循环队列习题———>力扣622 设计循环队列
题目分析：
设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能利用这些空间去存储新的值。你的实现应该支持如下操作：
MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。
首先我们设计这个用什么数据结构实现呢？
如果是链表，我们找尾的前一个十分不方便。创建也有点稍微麻烦。
如果是数组，我们利用下标可以访问到任意位置，但是循环起来不太好办，并且会有下标边界需要考虑。
所以综上我们可以使用链表，也可以使用数组，我们这次使用数组来实现吧。
代码实现：
循环器的构造：
typedef struct { int k; int *a; int head; int tail; } MyCircularQueue;其实就是构造循环队列的结构体，这里我们首先要有一个动态的数组（int* a），队列的特性中我们得知还要有 头部（head） 和 尾部（tail），还要有一个存放队列长度的值（k）。
循环器的初始化：
MyCircularQueue* myCircularQueueCreate(int k) { MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue)); if(obj == NULL) { exit(-1); } obj->a = malloc(sizeof(int)*(k+1)); if(obj->a == NULL) { exit(-1); } obj->head = obj->tail = 0; obj->k = k; return obj; }首先我们先开辟一段空间是存放循环器的内容，存放的是动态数组，头部，尾部和队列的元素个数，然后我们还要再开辟一段空间存放循环器中元素的内容，就是动态数组部分的空间，动态数组开辟时我们要比平时多开一个元素大小的空间，是为了判断循环器是否已经满了，接着我们进行赋值初始化就好了。
注意一点，我们开辟的是K+1个元素大小的数组，实际初始化时，元素的个数的值是k。
循环器的销毁：
void myCircularQueueFree(MyCircularQueue* obj)//销毁 { free(obj->a); free(obj); }销毁和开辟同理，我们应该是 free 两次，先 free 掉动态开辟的数组，在 free 掉循环器队列，因为我们如果先free掉循环器队列就找不到动态数组了，形成内存泄漏了。
判断循环器是否为空，是否满了：
bool myCircularQueueIsEmpty(MyCircularQueue* obj) //循环其是否为空 { return obj->head == obj->tail; } bool myCircularQueueIsFull(MyCircularQueue* obj) //循环器是否满 { int next = obj->tail+1; next %= (obj->k+1); return next == obj->head; }这里我们还是采用返回一个表达式，来判断布尔值。
注意的一点：我们在判断是否为满时，可能出现以下的情况，我们一般有两种办法一个是控制边界，一个是采用模数据，下面的情况当 tail +1 到最大值时，我们就该进入下一个循环了，我们就要采用上述办法之一了，下面一些情况一样，为了保证整体代码的统一性，我都采用模数据的形式来写。
循环器的插入：
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)//插入 { if(myCircularQueueIsFull(obj)) { return false; } obj->a[obj->tail] = value; obj->tail++; obj->tail %= (obj->k+1); return true; }首先我们先考虑边界情况，如果插入的是最后一个，且插入后循环器没有满，我们要模数据，使得tail 移到最前面，我们正常插入，obj->tail ++ ，然后把这个数模上（k+1）即可。
循环队列的删除：
bool myCircularQueueDeQueue(MyCircularQueue* obj)//删除 { if(myCircularQueueIsEmpty(obj)) { return false; } obj->head++; obj->head %= (obj->k+1); return true; }极限情况head在最后，我们还是要模数据，和上述插入一样。
取循环器队列头部数据：
int myCircularQueueFront(MyCircularQueue* obj)//取队列头部数据 { if(myCircularQueueIsEmpty(obj)) { return -1; } return obj->a[obj->head]; }取头部数据很简单，我们只需要在队列不为空的时候，返回 obj->head 就好啦。
取循环器队列尾部数据：
int myCircularQueueRear(MyCircularQueue* obj)//队列尾部数据 { if(myCircularQueueIsEmpty(obj)) { return -1; } int prev = obj->tail-1+obj->k+1; return obj->a[prev % (obj->k+1)]; }极限情况如下：
我们要取队列尾部数据，那么我们就要找到尾部，这个情况下尾部可以看成K+1-1 % (k+1)的结果，我们对这个公式推广后得到，我们发现，其实就是加上整个动态数组的大小在模上动态数组的大小，就可以得到尾部啦。
整体题解：
模数据 版题解：
typedef struct { int k; int *a; int head; int tail; } MyCircularQueue; MyCircularQueue* myCircularQueueCreate(int k) { MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue)); if(obj == NULL) { exit(-1); } obj->a = malloc(sizeof(int)*(k+1)); if(obj->a == NULL) { exit(-1); } obj->head = obj->tail = 0; obj->k = k; return obj; } bool myCircularQueueIsEmpty(MyCircularQueue* obj) { return obj->head == obj->tail; } bool myCircularQueueIsFull(MyCircularQueue* obj) { int next = obj->tail+1; next %= (obj->k+1); return next == obj->head; } bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) { if(myCircularQueueIsFull(obj)) { return false; } obj->a[obj->tail] = value; obj->tail++; obj->tail %= (obj->k+1); return true; } bool myCircularQueueDeQueue(MyCircularQueue* obj) { if(myCircularQueueIsEmpty(obj)) { return false; } obj->head++; obj->head %= (obj->k+1); return true; } int myCircularQueueFront(MyCircularQueue* obj) { if(myCircularQueueIsEmpty(obj)) { return -1; } return obj->a[obj->head]; } int myCircularQueueRear(MyCircularQueue* obj) { if(myCircularQueueIsEmpty(obj)) { return -1; } int prev = obj->tail-1+obj->k+1; return obj->a[prev % (obj->k+1)]; } void myCircularQueueFree(MyCircularQueue* obj) { free(obj->a); free(obj); }控制边界的题解：
typedef struct { int k; int *a; int head; int tail; } MyCircularQueue; MyCircularQueue* myCircularQueueCreate(int k) { MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue)); if(obj == NULL) { exit(-1); } obj->a = malloc(sizeof(int)*(k+1)); if(obj->a == NULL) { exit(-1); } obj->head = obj->tail = 0; obj->k = k; return obj; } bool myCircularQueueIsEmpty(MyCircularQueue* obj) { return obj->head == obj->tail; } bool myCircularQueueIsFull(MyCircularQueue* obj) { int next = obj->tail+1; if(next == obj->k+1) { next = 0; } return next == obj->head; } bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) { if(myCircularQueueIsFull(obj)) { return false; } obj->a[obj->tail] = value; obj->tail++; if(obj->tail == obj->k+1) { obj->tail = 0; } return true; } bool myCircularQueueDeQueue(MyCircularQueue* obj) { if(myCircularQueueIsEmpty(obj)) { return false; } obj->head++; if(obj->head == obj->k+1) { obj->head = 0; } return true; } int myCircularQueueFront(MyCircularQueue* obj) { if(myCircularQueueIsEmpty(obj)) { return -1; } return obj->a[obj->head]; } int myCircularQueueRear(MyCircularQueue* obj) { if(myCircularQueueIsEmpty(obj)) { return -1; } int prev = obj->tail-1; if(obj->tail == 0) { prev = obj->k; } return obj->a[prev]; } void myCircularQueueFree(MyCircularQueue* obj) { free(obj->a); free(obj); }
今天到这里结束啦！