（超详细）数据结构——“队列”的深度解析

 

目录

 

前言：

1.队列的概念   

2.队列的实现 

3.代码实现队列 

3.1 队列的初始化 

3.2 插入 

3.3 删除 

3.4 队列的队头，队尾和大小

3.5 判空 

3.6 销毁 

3.7 测试 

 

---

前言：

    队列与栈都是线性表，它们的结构也非常类似，都是一头进一头出，那么它们有什么区别吗？答案是有的，虽然它们同为线性表，但是栈的出栈入栈方式为后进先出，而队列的出栈入栈方式为先进先出，具体我们在正文讲解。

1.队列的概念   

2.队列的实现 

    队列与栈的结构类似，所以它和栈一样，使用链表和顺序表都可以实现队列，但是由于队列遵循先进先出的顺序，如果使用顺序表进行头删实现出队列的话，整个队列的数据需要频繁向前移动，代码效率相对较低，而使用链表的头删实现出队列的话，只需要将头节点删除即可，所以综上所述，我们将使用链表来实现队列。

3.代码实现队列 

    为了方便管理，我们还是将队列分为三个文件实现，分别是Queue.h （queue中译是队列的意思），Queue.c和test.c，由于我们选择使用链表实现队列，所以我们要先使用结构体实现一个单链表的节点，这个节点包含数据和下一个节点的地址，存储数据变量的类型由我们将来要存储的数据决定，所以我们使用typedef队对数据类型进行改名，在这里我们将int作为测试类型，所以我们要对int重命名：

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

   基于队列先进先出的原则，我们需要得到队列的头和尾，必要时还需要知道队列的大小，所以我们额外创建一个结构体来存储队列的首地址，尾地址和队列的大小：

typedef struct Queue
{
	QNode* Qtail;
	QNode* Qhead;
	int size;
 
}Queue;

3.1 队列的初始化 

   我们现在有两个结构体，我们该如何初始化呢？是对两个结构体都初始化，还是对其中某一个初始化呢。答案是对存储有队列首地址和尾地址的结构体初始化，因为代表链表节点的QNode结构体的初始化是在我们在堆上开辟新的空间时初始化，所以我们这个时候的初始化是对Queue初始化：

void QInit(Queue* pq)
{
	assert(pq);
	pq->Qhead = pq->Qtail = NULL;
	pq->size = 0;
 
}//初始化

3.2 插入 

    我们这里的队列使用的是单链表，所以插入要使用尾插，删除使用头插，单链表的这两个操作完美的符合队列的先进先出的特性。在插入数据前，我们要先开辟一个新节点，如果这个节点有效，我们就对它初始化，让它的next指针指向空，将x赋给val。将新节点初始化完了之后，我们就要考虑插入的问题了，如果队列里没有任何成员，我们要插入的新节点就要同时赋给头指针和尾指针，如果队列里有成员，我们插入的新节点就只需要给尾指针的next指针，执行完插入操作后让size加1：

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->next = NULL;
	newnode->val = x;
 
	if (pq->Qhead == NULL)
	{
		pq->Qhead = pq->Qtail = newnode;
	}
	else
	{
		pq->Qtail->next = newnode;
		pq->Qtail = newnode;
	}
	pq->size++;
}//插入

3.3 删除 

    删除操作我们在前面讲过要使用头删，我们需要考虑队列是否为空，如果队列为空，则让程序无法执行删除操作，我们选择使用断言来限制队列为空使用删除的情况，与插入相同，我们需要考虑两种情况，如果队列中只有只有一个成员，那么这个成员同时被头指针和尾指针指着，如果我们要删除这个节点，那么我们要将头指针和尾指针同时置空，这样做是为了防止出现空指针的现象。第二种则是正常情况，我们用一个指针存储头指针的下一个节点的地址，将头指针指向的那块空间释放后（删除节点），再让头指针指向我们之前存储的地址，这样删除操作就算完成了：

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->Qhead);
 
	if (pq->Qhead->next == NULL)
	{
		free(pq->Qhead);
		pq->Qhead = pq->Qtail = NULL;
	}
	else
	{
		QNode* next = pq->Qhead->next;
		free(pq->Qhead);
		pq->Qhead = next;
	}
	pq->size--;
}//删除

3.4 队列的队头，队尾和大小

  队列的队头和队尾只需要将头指针和尾指针指向成员的值返回就可以了，而队列的大小也比较简单，只需要返回size就可以了：

队头：

DataType QueueFront(Queue* pq)
{
	assert(pq);
	return pq->Qhead->val;
}

队尾：

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

队列大小：

int Queuesize(Queue* pq)
{
	assert(pq);
	assert(pq->size >= 0);
	return pq->size;
}//大小

3.5 判空 

  我们有时会频繁对队列进行删除插入操作，这时我们可以使用这个方法来决定是否删除，如果队列为空，则不进行删除操作：

bool QEmpty(Queue* pq)
{
	assert(pq);
	assert(pq->size >= 0);
	return pq->size == 0;
}//判空

3.6 销毁 

  我们链表的节点都是从堆上开辟的，所以要手动将这些空间释放：

void QDestroy(Queue* pq)
{
	assert(pq);
	Queue* cur = pq->Qhead;
 
	while (cur)
	{
		QNode* next = cur->Qhead->next;
		free(cur->Qhead);
		cur->Qhead = next;
	}
	pq->Qhead = pq->Qtail = NULL;
	pq->size = 0;
}

3.7 测试 

  到这里队列所有的方法都已经实现了，实现完之后不要忘记测试一下代码的有效性，我们来测试一下我们实现的方法：

我们插入了四个数字，然后使用判空，队头和删除方法来打印队列，可以看到都是没有问题的，讲到这里，队列就到此结束了，代码放在下面，感兴趣的小伙伴可以试试哦。

Queue.h :

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
 
typedef int QDataType;
typedef struct QueueNode
{
	QDataType val;
	struct QueueNode* next;
 
 
}QNode;
 
typedef struct Queue
{
	QNode* Qtail;
	QNode* Qhead;
	int size;
 
}Queue;
 
void QInit(Queue* pq);//初始化
 
void QueuePush(Queue* pq, QDataType x);//插入
 
void QueuePop(Queue* pq);//删除
 
int Queuesize(Queue* pq);//大小
 
//头尾数据
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
//判空
bool QEmpty(Queue* pq);
 
void QDestroy(Queue* pq);//销毁
 
 

Queue.c :

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"
 
void QInit(Queue* pq)
{
	assert(pq);
	pq->Qhead = pq->Qtail = NULL;
	pq->size = 0;
 
}//初始化
 
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->next = NULL;
	newnode->val = x;
 
	if (pq->Qhead == NULL)
	{
		pq->Qhead = pq->Qtail = newnode;
	}
	else
	{
		pq->Qtail->next = newnode;
		pq->Qtail = newnode;
	}
	pq->size++;
}//插入
 
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->Qhead);
 
	if (pq->Qhead->next == NULL)
	{
		free(pq->Qhead);
		pq->Qhead = pq->Qtail = NULL;
	}
	else
	{
		QNode* next = pq->Qhead->next;
		free(pq->Qhead);
		pq->Qhead = next;
	}
	pq->size--;
}//删除
 
int Queuesize(Queue* pq)
{
	assert(pq);
	assert(pq->size >= 0);
	return pq->size;
}//大小
 
//头、尾数据
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	return pq->Qhead->val;
}
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	return pq->Qtail->val;
}
 
bool QEmpty(Queue* pq)
{
	assert(pq);
	assert(pq->size >= 0);
	return pq->size == 0;
}//判空
 
void QDestroy(Queue* pq)
{
	assert(pq);
	Queue* cur = pq->Qhead;
 
	while (cur)
	{
		QNode* next = cur->Qhead->next;
		free(cur->Qhead);
		cur->Qhead = next;
	}
	pq->Qhead = pq->Qtail = NULL;
	pq->size = 0;
}

test.c :

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"
void test()
{
	Queue q;
	QInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
 
 
	while (!QEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	printf("\n");
 
	QDestroy(&q);
 
}
int main()
{
	test();
	return 0;
}