用链表实现队列（C语言）（队列的基本操作：创建，销毁尾插，头删，返回队首队尾元素，返回队列大小，判空和打印）

用链表实现队列

1、队列的概念：

**队列:**只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出
入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头

2、队列的结构

队列可以使用数组和链表结构实现，使用链表的结构更优，可以减少在出队的开销，数组在出队操作时的消耗较大

//顺序队列结构
#define MAX_SIZE 999
typedef int QueueDataType;

typedef struct Queue
{
	QueueDataType *array[MAX_SIZE ];
	int _front;//队头指针
	int _rear;//队尾指针
	size_t size;//队列大小
	size_t capacity;//队列的容量
}Queue;

//链表队列
typedef int QueueDataType;

typedef struct QueueNode
{
	struct QueueNode *_next;
	QueueDataType _data;
}QueueNode;

typedef struct Queue
{
	QueueNode *_front;
	QueueNode *_rear;
}Queue;

3、链表队列的实现

Queue.h

#ifndef _QUEUE_H_
#define _QUEUE_H_

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

typedef int QueueDataType;

typedef struct QueueNode
{
	struct QueueNode *_next;
	QueueDataType _data;
}QueueNode;

typedef struct Queue
{
	QueueNode *_front;
	QueueNode *_rear;
}Queue;

//初始化
void QueueInit(Queue *pqueue);
//销毁
void QueueDestory(Queue *pqueue);
//为链表开辟结点
QueueNode* BuyQueueNode(QueueDataType x);
//尾插
void QueuePush(Queue *pqueue, QueueDataType x);
//头删
void QueuePop(Queue *pqueue);
//返回队首元素
QueueDataType QueueFront(Queue *pqueue);
//返回队尾元素
QueueDataType QueueRear(Queue *pqueue);
//判空
int QueueEmpty(Queue *pqueue);
//返回队列长度
int QueueSize(Queue *pqueue);
//打印
void QueuePrint(Queue *pqueue);
#endif //_QUEUE_H_

Queue.c

#include "Queue.h"

//初始化
void QueueInit(Queue *pqueue)
{
	assert(pqueue);
	pqueue->_front = NULL;
	pqueue->_rear = NULL;
}

//销毁
void QueueDestory(Queue *pqueue)
{
	assert(pqueue);
	QueueNode *cur = pqueue->_front;
	while (cur)
	{
		QueueNode *tmp = cur->_next;
		free(cur);
		cur = tmp;
	}
	pqueue->_front = NULL;
	pqueue->_rear = NULL;
}

//为链表开辟结点
QueueNode* BuyQueueNode(QueueDataType x)
{
	QueueNode *queuenode = (QueueNode *)malloc(sizeof(QueueNode));
	if (queuenode != NULL)
	{
		queuenode->_data = x;
		queuenode->_next = NULL;
		return queuenode;
	}
	return NULL;
}

//尾插
void QueuePush(Queue *pqueue, QueueDataType x)
{
	assert(pqueue);
	QueueNode *queuenode = BuyQueueNode(x);
	if (QueueEmpty(pqueue))
	{
		pqueue->_front = queuenode;
		pqueue->_rear = queuenode;
	}
	else
	{
		pqueue->_rear->_next = queuenode;
		pqueue->_rear = queuenode;
	}
}

//头删
void QueuePop(Queue *pqueue)
{
	assert(pqueue);
	QueueNode *tmp = pqueue->_front;
	pqueue->_front = tmp->_next;
	free(tmp);
	tmp = NULL;
}

//返回队首元素
QueueDataType QueueFront(Queue *pqueue)
{
	assert(pqueue);
	return pqueue->_front->_data;
}

//返回队尾元素
QueueDataType QueueRear(Queue *pqueue)
{
	assert(pqueue);
	return pqueue->_rear->_data;
}

//判空
int QueueEmpty(Queue *pqueue)
{
	assert(pqueue);
	return pqueue->_front == NULL;
}

//返回队列长度
int QueueSize(Queue *pqueue)
{
	assert(pqueue);
	int count = 0;
	QueueNode *cur = pqueue->_front;
	for (; cur; cur = cur->_next)
	{
		count++;
	}
	return count;
}

//打印
void QueuePrint(Queue *pqueue)
{
	assert(pqueue);
	printf("front <== ");
	QueueNode *cur = pqueue->_front;
	for (; cur; cur = cur->_next)
	{
		printf(" %d <==", cur->_data);
	}
	printf(" real\n");
}

main.c

#include "Queue.h"

int main()
{
	Queue queue;
	QueueInit(&queue);
	QueuePush(&queue, 1);
	QueuePush(&queue, 2);
	QueuePush(&queue, 3);
	QueuePush(&queue, 4);
	QueuePush(&queue, 5);
	QueuePush(&queue, 6);
	QueuePush(&queue, 7);
	QueuePush(&queue, 8);
	QueuePush(&queue, 9);
	QueuePush(&queue, 10);
	QueuePrint(&queue);
	QueuePop(&queue);
	QueuePrint(&queue);
	printf("QueueFront = %d\n", QueueFront(&queue));
	printf("QueueRear = %d\n", QueueRear(&queue));
	printf("QueueEmpty = %d\n", QueueEmpty(&queue));
	printf("QueueSize = %d\n", QueueSize(&queue));
	QueueDestory(&queue);
	system("pause");
	return 0;
}