数据结构（队列的实现）

队列：队列是一种特殊的线性表，特殊之处在于它只允许在表的前端进行删除操作，只在表的后端进行插入操作，既和栈一样，队列是一种受限制的线性表。进行插入操作的端为队尾，进行删除操作的端为队头

Queue.h

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>

typedef int QDataType;
typedef struct QueueNode
{
	QDataType _data;    //当前结点存储数据
	struct QueueNode* _next;   //指向下一个节点
}QNode;

typedef struct Queue
{
	QNode* _head;     //指向队列的头
	QNode* _tail;     //指向队列的尾
}Qu;

void QueueInit(Qu*pq);   
//队列的初始化：构造一个空队
void QueueDestory(Qu* pq);    
//队列的销毁：置空队列
void QueuePrint(Qu* pq);      
// 队列的打印：输出队列中数据
QNode* BuyQueueNode(QDataType x);    
//新建结点：单独结点
void QueuePush(Qu* pq, QDataType x);    
// 队尾插入（入队）：对已存在的队列，插入一个元素到队尾，队发生变化
void QueuePop(Qu* pq);               
//队头删除（出队）：对已存在队列，删除一个队首元素，队发生变化
QDataType QueueFront(Qu* pq);        
//取队头元素：读队首元素，并返回其值，队不变
QDataType QueueBack(Qu*pq);        
//取队头元素：读队尾元素，并返回其值，队不变
int QueueEmpty(Qu* pq);         
//判断队列是否为空：若为空队列则返回0，否则返回1
int QueueSize(Qu* pq);        
//计算队列的元素个数并返回此值，队不变

void TestQueue();           
//测试函数：测试上述函数功能

Queue.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "Queue.h"
    
void QueueInit(Qu* pq)
{
	QDataType x = 0;
	assert(pq);
	pq->_head = BuyQueueNode(x);    //定义一个头结点
	pq->_tail = pq->_head;
}

void QueueDestory(Qu* pq)
{
	QNode* cur = pq->_head->_next;    //cur是当前队列的第一个结点
	while (cur != NULL)              //释放所有结点
	{
		QNode* next = cur->_next;
		free(cur);
		cur = next;
	}
}

QNode* BuyQueueNode(QDataType x)
{
	QNode* newNode = (QNode*)malloc(sizeof(QNode));
	newNode->_data = x;
	newNode->_next = NULL;
	return newNode;
}

void QueuePush(Qu* pq, QDataType x)
{
	QNode* newnode = BuyQueueNode(x);
	pq->_tail->_next = newnode;    //将新结点放在队尾
	pq->_tail = newnode;
}

void QueuePop(Qu* pq)
{
	assert(pq);
	QNode* 	cur = pq->_head->_next;
	if (cur == NULL)       // 若队列中无元素
	{
		return;
	}
	if (cur == pq->_tail)     //若队列中只有一个元素
	{
		pq->_tail = pq->_head;
	}
	pq->_head->_next = cur->_next;
	free(cur);
}

QDataType QueueFront(Qu* pq)
{
	QNode* 	cur = pq->_head->_next;
	assert(pq);
	return cur->_data;
}

QDataType QueueBack(Qu*pq)
{
	assert(pq);
	return pq->_tail->_data;
}

int QueueEmpty(Qu* pq)
{
	QNode* 	cur = pq->_head->_next;
	if (cur == NULL)
		return 0;
	else return 1;
}

int QueueSize(Qu* pq)
{
	int count = 0;
	QNode* 	cur = pq->_head->_next;
	if (cur == NULL)
		return 0;
	while (cur)
	{
		count++;
		cur = cur->_next;
	}
	return count;
}

void QueuePrint(Qu* pq)
{
	QNode* 	cur = pq->_head->_next;
	assert(pq);
	while (cur != NULL)
	{
		printf("%d  ", cur->_data);
		cur = cur->_next;
	}
	printf("\n");
}

void TestQueue()
{
	int i = 0;
	Qu queue;
	QueueInit(&queue);
	printf("初始化队列完成 \n");
	printf("尾插的结果是： ");
	QueuePush(&queue, 1);
	QueuePush(&queue, 2);
	QueuePush(&queue, 3);
	QueuePush(&queue, 4);
	QueuePrint(&queue);
	printf("头删的结果是： ");
	QueuePop(&queue);
	QueuePrint(&queue);
	printf("队列的头结点是： %d \n", QueueFront(&queue));
	printf("队列的尾结点是： %d \n", QueueBack(&queue));
	i = QueueEmpty(&queue);
	if (i == 0)  printf("队列为空！\n ");
	else   printf("队列非空 \n ");
	printf("队列的个数是： %d \n", QueueSize(&queue));
	QueueDestory(&queue);
	printf("销毁成功！\n");
}

Test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "Queue.h"

int main()
{
	printf("      *******队列的实现******\n");
	TestQueue();
	printf("\n");
	printf("\n");
	printf("\n");
	system("pause");
	return 0;
}