数据结构——队列的实现

队列，又称为伫列（queue），计算机科学中的一种抽象资料类型，是先进先出（FIFO, First-In-First-Out）的线性表。在具体应用中通常用链表或者数组来实现。队列只允许在后端（称为rear）进行插入操作，在前端（称为front）进行删除操作。

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

这段代码使用 typedef 关键字定义了一个名为 QueueNode 的结构体。QueueNode 结构体包含两个成员：

一个指向另一个 QueueNode 结构体的指针，名为 next，用于表示队列中的下一个节点。
一个名为 data 的变量，其数据类型为 QDataType，用于表示节点中存储的数据。
QNode 被定义为 struct QueueNode* 的别名，也就是说，QNode 是一个指向 QueueNode 结构体的指针。

总的来说，这段代码定义了一个链表节点结构体，可以用来实现队列数据结构，其中每个节点包含一个数据元素和一个指向队列中下一个节点的指针。

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

这段代码使用 typedef 关键字定义了一个名为 Queue 的结构体。Queue 结构体包含三个成员变量：

一个指向 QNode 结构体的指针，名为 head，用于表示队列中的第一个节点。
一个指向 QNode 结构体的指针，名为 tail，用于表示队列中的最后一个节点。
一个整型变量，名为 size，用于表示队列中节点的数量。
这个结构体可以用来实现一个队列数据结构，其中 head 指向队列的开头，tail 指向队列的结尾，size 记录队列中节点的数量。通常情况下，向队列中添加一个节点会使 tail 指针指向新的节点，从队列中移除一个节点会使 head 指针指向下一个节点，并更新 size 的值。

//初始化队列
void QueueInit(Queue* q)
{
	assert(q);
	q->head = q->tail = NULL;
	q->size = 0;
}

这段代码定义了一个名为 QueueInit 的函数，用于初始化一个队列。函数中传入一个指向 Queue 结构体的指针 q，并使用 assert 宏断言 q 不为 NULL。

函数的实现非常简单，将 q 的 head 和 tail 成员都赋值为 NULL，将 size 成员赋值为 0，这样就完成了队列的初始化操作。由于 q 是一个指针，函数中对其进行的操作实际上是对传入的队列进行修改，因此不需要返回值。

// 队尾入队列
void QueuePush(Queue* q, QDataType data)
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = data;
	newnode->next = NULL;

	if (q->head == NULL)
	{
		assert(q->tail == NULL);
		q->head = q->tail = newnode;
	}
	else
	{
		q->tail->next = newnode;
		q->tail = newnode;
	}
	q->size++;

这段代码定义了一个名为 QueuePush 的函数，用于将一个元素插入到队列的尾部。函数中传入一个指向 Queue 结构体的指针 q，以及要插入的数据 data。

函数的实现分为以下几步：

使用 malloc 函数动态分配一个 QNode 结构体大小的内存空间，并将其强制转换为指向 QNode 结构体的指针 newnode。
检查 newnode 是否为空，如果为空则输出错误信息并返回。
将 newnode 的 data 成员赋值为传入的 data，将 newnode 的 next 成员赋值为 NULL，表示 newnode 是队列中的最后一个节点。
检查队列是否为空。如果队列为空，则将队列的 head 和 tail 成员都指向 newnode，表示 newnode 是队列中唯一的节点。
如果队列不为空，则将队列的 tail 节点的 next 指针指向 newnode，表示将 newnode 插入到队列的尾部，并将 tail 指针指向 newnode，表示 newnode 现在是队列中的最后一个节点。
将队列的 size 成员加1，表示队列中节点的数量增加了1。
由于队列是由指针链表实现的，因此在插入节点时需要进行动态内存分配，并将相邻节点的指针进行修改。

// 队头出队列
void QueuePop(Queue* q)
{
	assert(q);
	assert(q->head != NULL);
	QNode* next = q->head->next;
	free(q->head);
	q->head = next;
	if (q->head == NULL)
		q->tail = NULL;
	q->size--;
}

这段代码定义了一个名为 QueuePop 的函数，用于将队列头部的元素弹出队列。函数中传入一个指向 Queue 结构体的指针 q。

函数的实现分为以下几步：

使用 assert 宏检查传入的 q 不为空，以及队列的 head 成员不为 NULL。如果检查失败，则直接返回。
将队列的 head 节点的 next 指针赋值给 next，表示队列头部的下一个节点。
释放队列的 head 节点所占用的内存空间。
将队列的 head 指针指向 next，表示将队列头部的节点弹出队列。
如果队列的 head 成员为 NULL，则将队列的 tail 成员也赋值为 NULL，表示队列已经为空。
将队列的 size 成员减1，表示队列中节点的数量减少了1。
由于队列是由指针链表实现的，因此在弹出节点时需要释放节点的内存空间，并将相邻节点的指针进行修改。

// 获取队列头部元素
QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->head->data;
}

这段代码定义了一个名为 QueueFront 的函数，用于获取队列头部的元素。函数中传入一个指向 Queue 结构体的指针 q。

函数的实现分为以下几步：

使用 assert 宏检查传入的 q 不为空，以及队列不为空。如果检查失败，则直接返回。
返回队列的 head 节点的 data 成员，即队列头部的元素。
由于队列是由指针链表实现的，因此可以通过访问队列头部节点的 data 成员来获取队列头部的元素。

// 获取队列队尾元素
QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->tail->data;
}

这段代码定义了一个名为 QueueBack 的函数，用于获取队列尾部的元素。函数中传入一个指向 Queue 结构体的指针 q。

函数的实现分为以下几步：

使用 assert 宏检查传入的 q 不为空，以及队列不为空。如果检查失败，则直接返回。
返回队列的 tail 节点的 data 成员，即队列尾部的元素。
由于队列是由指针链表实现的，因此可以通过访问队列尾部节点的 data 成员来获取队列尾部的元素。

// 获取队列中有效元素个数
int QueueSize(Queue* q)
{
	assert(q);
	return q->size;
}

这段代码定义了一个名为 QueueSize 的函数，用于获取队列中有效元素的数量。函数中传入一个指向 Queue 结构体的指针 q。

函数的实现非常简单，直接返回队列的 size 成员，即队列中有效元素的数量。由于 size 成员是在队列的操作过程中动态更新的，因此可以通过该成员来获取队列中有效元素的数量。

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
bool QueueEmpty(Queue* q)
{
	assert(q);
	return q->size == 0;
}

这段代码定义了一个名为 QueueEmpty 的函数，用于判断队列是否为空。函数中传入一个指向 Queue 结构体的指针 q。

函数的实现非常简单，通过检查队列的 size 成员是否为0来判断队列是否为空。如果 size 等于0，则队列为空，返回 true（非零结果），否则队列非空，返回 false（0）。

// 销毁队列
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	q->head = q->tail = NULL;
	q->size = 0;
}

这段代码定义了一个名为 QueueDestroy 的函数，用于销毁一个队列。函数中传入一个指向 Queue 结构体的指针 q。

函数的实现分为以下几步：

使用 assert 宏检查传入的 q 不为空。
将队列的 head 指针赋值给 cur，表示从队列的头部开始销毁节点。
循环遍历队列中的所有节点，每次将 cur 的 next 指针赋值给 next，然后释放 cur 指向的节点所占用的内存空间。
将 cur 指针指向 next，即将指针移动到下一个节点，继续进行循环直到遍历完所有节点。
将队列的 head 和 tail 成员都赋值为 NULL，将队列的 size 成员赋值为 0，表示队列已经被销毁。
由于队列是由指针链表实现的，因此在销毁队列时需要释放每个节点所占用的内存空间，并将指针移动到下一个节点。

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

// 初始化队列
void QueueInit(Queue* q);
// 队尾入队列
void QueuePush(Queue* q, QDataType data);
// 队头出队列
void QueuePop(Queue* q);
// 获取队列头部元素
QDataType QueueFront(Queue* q);
// 获取队列队尾元素
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
bool QueueEmpty(Queue* q);
// 销毁队列
void QueueDestroy(Queue* q);

//初始化队列
void QueueInit(Queue* q)
{
	assert(q);
	q->head = q->tail = NULL;
	q->size = 0;
}
// 队尾入队列
void QueuePush(Queue* q, QDataType data)
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = data;
	newnode->next = NULL;

	if (q->head == NULL)
	{
		assert(q->tail == NULL);
		q->head = q->tail = newnode;
	}
	else
	{
		q->tail->next = newnode;
		q->tail = newnode;
	}
	q->size++;

}
// 队头出队列
void QueuePop(Queue* q)
{
	assert(q);
	assert(q->head != NULL);
	QNode* next = q->head->next;
	free(q->head);
	q->head = next;
	if (q->head == NULL)
		q->tail = NULL;
	q->size--;
}
// 获取队列头部元素
QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->head->data;
}
// 获取队列队尾元素
QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->tail->data;
}
// 获取队列中有效元素个数
int QueueSize(Queue* q)
{
	assert(q);
	return q->size;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
bool QueueEmpty(Queue* q)
{
	assert(q);
	return q->size == 0;
}
// 销毁队列
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	q->head = q->tail = NULL;
	q->size = 0;
}
int main()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	printf("\n");
	
	QueueDestroy(&q);
	return 0;
}