数据结构中，队列用来存储逻辑关系为“一对一”的数据，是一种“特殊”的线性存储结构。
队列是什么
和顺序表、链表相比，队列的特殊性体现在以下两个方面： 1、元素只能从队列的一端进入，从另一端出去，如下图所示：
图 1 队列存储结构
通常，我们将元素进入队列的一端称为“队尾”，进入队列的过程称为“入队”；将元素从队列中出去的一端称为“队头”，出队列的过程称为“出队”。 2、队列中各个元素的进出必须遵循“先进先出”的原则，即最先入队的元素必须最先出队。 以图 1 所示的队列为例，从各个元素在队列中的存储状态不难判定，元素 1 最先入队，然后是元素 2 入队，最后是元素 3 入队。如果此时想将元素 3 出队，根据“先进先出”原则，必须先将元素 1 和 2 依次出队，最后才能轮到元素 3 出队。
强调：栈和队列不要混淆，栈是一端开口、另一端封口，元素入栈和出栈遵循“先进后出”原则；队列是两端都开口，但元素只能从一端进，从另一端出，且进出队列遵循“先进先出”的原则。
队列的具体实现
和栈的实现方案一样，队列的实现也有两种方式，分别是：
顺序队列：用顺序表模拟实现队列存储结构；
链队列：用链表模拟实现队列存储结构。
两者的区别仅是顺序表和链表的区别，即顺序队列集中存储数据，而链队列分散存储数据，元素之间的逻辑关系靠指针维系。
队列的基本操作（入队和出队）
1) 顺序队列的基本操作
顺序队列指的是用顺序表模拟实现的队列存储结构。 我们知道，队列具有以下两个特点：
数据从队列的一端进，从另一端出；
数据的入队和出队遵循"先进先出"的原则；
在顺序表的基础上，只要元素进出的过程遵循以上两个规则，就能实现队列结构。
顺序队列的具体实现
通常情况下，我们采用 C 语言中的数组实现顺序表。既然用顺序表模拟实现队列，必然要先定义一个足够大的数组。不仅如此，为了遵守队列中数据从 "队尾进，队头出" 且 "先进先出" 的规则，还需要定义两个变量（top 和 rear）分别记录队头和队尾的具体位置，如图 1 所示：
图 1 顺序队列实现示意图
初始状态下，顺序队列中没有任何元素，因此 top 和 rear 重合，都位于 a[0] 处。
实现入队
在图 1 的基础上，当有新元素入队时，依次执行以下两步操作：
将新元素存储在 rear 记录的位置；
更新 rear 的值（rear+1），记录下一个空闲空间的位置，为下一个新元素入队做好准备。
例如，在图 1 基础上将 {1,2,3,4} 用顺序队列存储的实现操作如图 2 所示：
图 2 数据进顺序队列的过程实现示意图
入队操作的 C 语言实现代码如下：
1 int enQueue(int* a, int rear, int data) {
2 //如果 rear 超出数组下标范围，队列将无法继续添加元素
3 if (rear == MAX_LEN) {
4 printf("队列已满，添加元素失败\n");
5 return rear;
6 }
7 a[rear] = data;
8 rear++;
9 return rear;
10 }
实现出队
当有元素出队时，根据“先进先出”的原则，目标元素以及在它之前入队的元素要依次从队头出队。 出队操作的实现方法很简单，就是更新 top 的值（top+1）。例如，在图 2 基础上，顺序队列中元素逐个队列的过程如图 3 所示：
图 3 数据出顺序队列的过程示意图
注意，虽然数组中仍保存着 1、2、3、4 这些元素，但队列中的元素是依靠 top 和 rear 来判别的，因此图 3b) 显示的队列中确实不存在任何元素。
出队操作的 C 语言实现代码为：
1 int deQueue(int* a, int top, int rear) {
2 //如果 top==rear，表示队列为空
3 if (top== rear) {
4 printf("队列已空，出队执行失败\n");
5 return top;
6 }
7 printf("出队元素：%d\n", a[top]);
8 top++;
9 return top;
10 }
顺序队列的完整实现代码
使用顺序表模拟实现顺序队列的 C 语言代码为：
1 #include
2 #define MAX_LEN 100 //规定数组的长度
3 //实现入队操作
4 int enQueue(int* a, int rear, int data) {
5 //如果 rear 超出数组下标范围，队列将无法继续添加元素
6 if (rear == MAX_LEN) {
7 printf("队列已满，添加元素失败\n");
8 return rear;
9 }
10 a[rear] = data;
11 rear++;
12 return rear;
13 }
14 //实现出队操作
15 int deQueue(int* a, int top, int rear) {
16 //如果 top==rear，表示队列为空
17 if (top == rear) {
18 printf("队列已空，出队执行失败\n");
19 return top;
20 }
21 printf("出队元素：%d\n", a[top]);
22 top++;
23 return top;
24 }
25 int main() {
26 int a[MAX_LEN];
27 int top, rear;
28 //设置队头指针和队尾指针，当队列中没有元素时，队头和队尾指向同一块地址
29 top = rear = 0;
30 //入队
31 rear = enQueue(a, rear, 1);
32 rear = enQueue(a, rear, 2);
33 rear = enQueue(a, rear, 3);
34 rear = enQueue(a, rear, 4);
35 //出队
36 top = deQueue(a, top, rear);
37 top = deQueue(a, top, rear);
38 top = deQueue(a, top, rear);
39 top = deQueue(a, top, rear);
40 top = deQueue(a, top, rear);
41 return 0;
42 }
程序输出结果：
出队元素：1 出队元素：2 出队元素：3 出队元素：4 队列已空，出队执行失败
2) 链式队列的基本操作
链式队列，简称"链队列"，即使用链表实现的队列存储结构。 链式队列的实现思想同顺序队列类似，创建两个指针（命名为 top 和 rear）分别指向链表中队列的队头元素和队尾元素，如图 1 所示：
图 1 链式队列的初始状态
图 1 所示为链式队列的初始状态，此时队列中没有存储任何数据元素，因此 top 和 rear 指针都同时指向头节点。
在创建链式队列时，强烈建议初学者创建一个带有头节点的链表，这样实现链式队列会更简单。
由此，我们可以编写出创建链式队列的 C 语言实现代码为：
1 //链表中的节点结构
2 typedef struct qnode{
3 int data;
4 struct qnode * next;
5 }QNode;
6 //创建链式队列的函数
7 QNode * initQueue(){
8 //创建一个头节点
9 QNode * queue=(QNode*)malloc(sizeof(QNode));
10 //对头节点进行初始化
11 queue->next=NULL;
12 return queue;
13 }
链式队列数据入队
链队队列中，当有新的数据元素入队，只需进行以下 3 步操作：
将该数据元素用节点包裹，例如新节点名称为 elem；
与 rear 指针指向的节点建立逻辑关系，即执行 rear->next=elem；
最后移动 rear 指针指向该新节点，即 rear=elem；
由此，新节点就入队成功了。 例如，在图 1 的基础上，我们依次将 {1,2,3} 依次入队，各个数据元素入队的过程如图 2 所示：
图 2 {1,2,3} 入链式队列
如图 2 中，我们将链表的头部作为队列的队头，将链表的尾部作为队列的队尾。当然，也可以反过来，将链表的头部（尾部）作为队列的队尾（队头），两种存储方式都可以。
数据元素入链式队列的 C 语言实现代码为：
1 QNode* enQueue(QNode * rear,int data){
2 //1、用节点包裹入队元素
3 QNode * enElem=(QNode*)malloc(sizeof(QNode));
4 enElem->data=data;
5 enElem->next=NULL;
6 //2、新节点与rear节点建立逻辑关系
7 rear->next=enElem;
8 //3、rear指向新节点
9 rear=enElem;
10 //返回新的rear，为后续新元素入队做准备
11 return rear;
12 }
链式队列数据出队
当链式队列中有元素需要出队时，按照 "先进先出" 的原则，需要先将在它之前入队的元素依次出队，然后该目标元素才能出队。 我们知道，队列中的元素只能从队头出队。在图 2 中，队列的队头位于链表的头部。因此队列中元素出队的过程，其实是链表中摘除首元结点的过程，需要做以下 3 步操作：
通过 top 指针直接找到队头节点，创建一个新指针 p 指向此即将出队的节点；
将 top 所指结点的 next 指针，指向 p 结点的直接后继结点；
释放节点 p 占用的内存空间；
例如，在图 2b) 的基础上，我们将元素 1 和 2 出队，则操作过程如图 3 所示：
图 3 链式队列中数据元素出队
链式队列中队头元素出队的 C 语言实现代码为：
1 QNode* DeQueue(QNode* top, QNode* rear) {
2 QNode* p = NULL;
3 if (top->next == NULL) {
4 printf("\n队列为空\n");
5 return rear;
6 }
7 // 1、创建新指针 p 指向目标结点
8 p = top->next;
9 printf("%d ", p->data);
10 //2、将目标结点从链表上摘除
11 top->next = p->next;
12 if (rear == p) {
13 rear = top;
14 }
15 //3、释放结点 p 占用的内存
16 free(p);
17 return rear;
18 }
注意，将队头元素做出队操作时，需提前判断队列中是否还有元素，如果没有，要提示用户无法做出队操作，保证程序的健壮性。此外，程序中要判断被摘除的目标结点是否是 rear 队头队尾，如果是的话，要及时更新 rear 指针的指向。
链式队列完整C语言实现代码
这里给出链式队列入队和出队的完整 C 语言代码为：
1 #include
2 #include
3 //链表中的节点结构
4 typedef struct qnode {
5 int data;
6 struct qnode* next;
7 }QNode;
8 //创建链式队列的函数
9 QNode* initQueue() {
10 //创建一个头节点
11 QNode* queue = (QNode*)malloc(sizeof(QNode));
12 //对头节点进行初始化
13 queue->next = NULL;
14 return queue;
15 }
16
17 QNode* enQueue(QNode* rear, int data) {
18 //1、用节点包裹入队元素
19 QNode* enElem = (QNode*)malloc(sizeof(QNode));
20 enElem->data = data;
21 enElem->next = NULL;
22 //2、新节点与rear节点建立逻辑关系
23 rear->next = enElem;
24 //3、rear指向新节点
25 rear = enElem;
26 //返回新的rear，为后续新元素入队做准备
27 return rear;
28 }
29
30 QNode* deQueue(QNode* top, QNode* rear) {
31 QNode* p = NULL;
32 if (top->next == NULL) {
33 printf("\n队列为空\n");
34 return rear;
35 }
36 // 1、创建新指针 p 指向目标结点
37 p = top->next;
38 printf("%d ", p->data);
39 //2、将目标结点从链表上摘除
40 top->next = p->next;
41 if (rear == p) {
42 rear = top;
43 }
44 //3、释放结点 p 占用的内存
45 free(p);
46 return rear;
47 }
48
49 int main() {
50 QNode* queue = NULL, * top = NULL, * rear = NULL;
51 queue = top = rear = initQueue();//创建头结点
52 //向链队列中添加结点，使用尾插法添加的同时，队尾指针需要指向链表的最后一个元素
53 rear = enQueue(rear, 1);
54 rear = enQueue(rear, 2);
55 rear = enQueue(rear, 3);
56 rear = enQueue(rear, 4);
57 //入队完成，所有数据元素开始出队列
58 rear = deQueue(top, rear);
59 rear = deQueue(top, rear);
60 rear = deQueue(top, rear);
61 rear = deQueue(top, rear);
62 rear = deQueue(top, rear);
63 return 0;
64 }
程序运行结果为：
1 2 3 4 队列为空
读到这里，相信你真的下定了决心要学习数据结构，系统学习可以买书、视频看，也可以找网上现有的教程跟着学，也可以报辅导班学，学习形式很多样，你可以根据自身情况考虑。想看免费教程的点这里，想跟着免费视频学习的，猛击这里下载，都是我多年珍藏的、还不错的，拿去用。