提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表。这里可以和栈进行对比，如果你还不知道栈那么你可以看看这篇文章链接: 一文了解栈。

---

一、队列是什么？

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)。
入队列：进行插入操作的一端称为队尾
出队列：进行删除操作的一端称为队头。
其具体结构如图所示

二、队列的实现

关于队列我们可以通过顺序表或双向链表或单链表来实现，但是考虑到这里需要从头部删除数据，如果使用顺序表则需要数组前移，时间复杂度高，代价高，所以我们不使用这种方法。如果使用双向链表，好像确实可以实现队列的功能，但每一个节点都需要多一个指向前一个节点的指针，会有一定消耗，所以这里我们选择单链表实现队列是比较合适的。具体实现想法如图

三、功能函数的实现

1.节点定义

代码如下（示例）：

typedef int QDataType;
typedef struct QueueNode
{
	QDataType val;//每一个节点的数据
	struct QueueNode* next;//指向下一个节点
}QNode;

这里我们再定义一个结构体

typedef struct Queue
{
	QNode* phead;//指向头节点
	QNode* ptail;//指向尾节点
	int size;//记录队列大小
}Queue;

这里提前说一下，因为我们在下面的函数实现传参时，需要经常传入头节点和尾节点，并且为了能改变其原来的值，我们需要传入地址，就会出现一大堆的QNode** pphead这样的二级指针，书写麻烦，所以我们定义一个结构体保存这两个节点，并且定义一个size记录队列大小。可以在下文代码中理解。

2.队列初始化

代码如下（示例）：

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}

这里使用指针之前我们首先判断其合法性，因为这是节点还没有建立，所以我们先把头节点和尾节点置为NULL，将size置为0.

3.队列销毁

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

这里我们先判断指针合法性，再用一个指针cur进行遍历链表，将申请的节点进行释放，最后将头节点和尾节点置NULL，将size置0即可。

4.队列尾插

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	newnode->next = NULL;
	newnode->val = x;
	if (pq->ptail == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}

队列只有尾插，所以这里我们就不再把申请链表节点的代码单独封装为函数。在malloc之后检查是否开辟成功，接着把新节点的next指针和val设置好后，进行一个判断，如果链表为空，则头节点和尾节点都需要指向新节点，如果链表不为空，则可以直接尾插。在这里，我们就可体验到直接在结构体中记录尾节点的方便性。

5.队列头删

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->size > 0);
	if (pq->phead == pq->ptail)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else
	{
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}
	pq->size--;
}

头删除了判断pq是否为空外，还需要判断队列是否为空。在之后的删除中也需要判断是否为一个节点，当只有一个节点时，需要头尾置空。不是一个节点时，可以直接删除。

6.返回队头数据

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->phead);
	return pq->phead->val;
}

这个代码就很好理解，先判断是否为空后，直接返回头节点数据即可。

7.返回队尾数据

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail);
	return pq->ptail->val;
}

返回队尾数据和返回队头数据逻辑一样，不再赘述。

8.返回队列大小

int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}

在判断完指针有效性后，可以直接返回size中记录的数据。

9.判空

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}

判空就是判断队列的size是否为零，判断后直接返回就行，为0返回true，不为零返回false。

9.一些思考

再写代码时我们会有以下思考：

1. 求队列元素，判空，求元素个数基本都是用一两行代码直接返回，这些接口会不会有些许多余，直接访问结构体相应成员不就好了？
2. 为什么没有像链表一样加入查找，打印，修改等接口？

首先，我们要知道，数据结构的实现方式多种多样，那么就会出现一个问题，如果我们使用别人已经封装好的队列，我们要怎么知道这些代码具体表示什么，我们完全不知道，只有设计者才知道，因此设计者往往会将这些功能再封装成函数，供我们直接调用。而且封装成函数方便我们的维护和使用。

这是因为队列是一种限制型数据结构，其不支持随机访问，只允许在固定的两端进行插入和删除操作，不允许在其他的位置进行任何操作。因此，队列不存在查找，打印，修改等对除队头队尾之外的位置进行操作的接口，否则会破坏队列的特性。为了遵循队列的特性，我们就不实现这些接口。

四、总体代码

1.头文件

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

typedef int QDataType;
typedef struct QueueNode
{
	QDataType val;
	struct QueueNode* next;
}QNode;

typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;

//队列的初始化和销毁
void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);

//队列尾插
void QueuePush(Queue* pq, QDataType x);

//队列头删
void QueuePop(Queue* pq);

//返回队列首元素
QDataType QueueFront(Queue* pq);

//返回队列尾元素
QDataType QueueBack(Queue* pq);

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

//判空
bool QueueEmpty(Queue* pq);

2.测试文件

#include"Queue.h"

int main()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	printf("\n");
	return 0;
}

---

总结

以上就是今天要讲的内容，本文仅仅简单介绍了队列的使用，而队列提供了大量能使我们快速便捷地处理数据想法和逻辑。期待你的一键三连。