用顺序表实现队列（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>

#define CAPACITY 2

typedef int QueueDataType;

typedef struct Queue
{
	QueueDataType *_array;
	int _front;
	int _rear;
	size_t _size;
	size_t _capacity;
}Queue;

//初始化
void QueueInit(Queue *pqueue, size_t capacity);
//销毁
void QueueDestory(Queue *pqueue);
//扩容
void CheckCapacity(Queue *pqueue);
//尾插
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, size_t capacity)
{
	assert(pqueue);
	pqueue->_capacity = capacity;
	pqueue->_array = (QueueDataType *)malloc(capacity*sizeof(QueueDataType));
	assert(pqueue->_array);
	pqueue->_front = 0;
	pqueue->_rear = 0;
	pqueue->_size = 0;
}

//销毁
void QueueDestory(Queue *pqueue)
{
	assert(pqueue);
	if (pqueue->_array)
	{
		free(pqueue->_array);
		pqueue->_array = NULL;
	}
	pqueue->_front = 0;
	pqueue->_rear = 0;
	pqueue->_size = 0;
	pqueue->_capacity = 0;
}

//扩容
void CheckCapacity(Queue *pqueue)
{
	assert(pqueue);
	if (pqueue->_size == pqueue->_capacity)
	{
		pqueue->_capacity *= CAPACITY;
		pqueue->_array = (QueueDataType *)realloc(pqueue->_size, CAPACITY*sizeof(QueueDataType));
	}
}

//尾插
void QueuePush(Queue *pqueue, QueueDataType x)
{
	assert(pqueue);
	CheckCapacity(pqueue);
	pqueue->_array[pqueue->_size] = x;
	pqueue->_size++;
	pqueue->_rear = pqueue->_size;
}

//头删
void QueuePop(Queue *pqueue)
{
	assert(pqueue);
	pqueue->_size--;
	pqueue->_front += 1;
	for (int i = 0; i <= pqueue->_size; i++)
	{
		pqueue->_array[i] = pqueue->_array[i + 1];
	}
}

//返回队首元素
QueueDataType QueueFront(Queue *pqueue)
{
	assert(pqueue);
	return pqueue->_array[0];
}

//返回队尾元素
QueueDataType QueueRear(Queue *pqueue)
{
	assert(pqueue);
	return pqueue->_array[pqueue->_size - 1];
}

//判空
int QueueEmpty(Queue *pqueue)
{
	assert(pqueue);
	return (pqueue->_size == 0) ? -1 : 1;
}

//返回队列长度
int QueueSize(Queue *pqueue)
{
	assert(pqueue);
	return	pqueue->_size;
}

//打印
void QueuePrint(Queue *pqueue)
{
	assert(pqueue);
	printf("front ");
	for (int i = 0; i < pqueue->_size; i++)
	{
		printf("<-- %d ", pqueue->_array[i]);
	}
	printf("<-- rear\n");
}

main.c

#include "Queue.h"

int main()
{
	Queue queue;
	QueueInit(&queue, 10);
	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;
}