队列

队列

队列的定义

队列是只能在队头出队（dequeue）,只能在队尾入队（enqueue）的表。

队列的实现

链表实现

链表队列的定义

typedef struct Node
{
	int m_Data;
	struct Node* m_Next;
}Node;
typedef struct Queue
{
	Node* m_Rear;	//队尾
	Node* m_Front;	//队首
	size_t m_Size;
}Queue;

判断队列是否为空

inline bool L_IsEmpty(const Queue* const queue)	//判断链表是否为空
{
	return queue->m_Front->m_Next == NULL;
}

创建队列

Queue* L_CreateQueue()	//创建队列
{
	Queue* queue = (Queue*)malloc(sizeof(Queue));
	if (!queue) {
		return NULL;
	}
	queue->m_Front = (Node*)malloc(sizeof(Node));
	if (!queue->m_Rear) {
		return NULL;
	}
	queue->m_Front->m_Next = NULL;
	queue->m_Rear = queue->m_Front;
	queue->m_Size = 0;
	return queue;
}

入队

void L_Enqueue(int data, Queue* queue)	//入队
{
	Node* tmp = (Node*)malloc(sizeof(Node));
	if (!tmp) {
		return;
	}
	tmp->m_Data = data;
	tmp->m_Next = queue->m_Rear->m_Next;
	queue->m_Rear->m_Next = tmp;
	queue->m_Rear = tmp;
	queue->m_Size++;
}

出队

void L_Dequeue(Queue* queue)	//出队
{
	assert(!L_IsEmpty(queue));
	Node* tmp = queue->m_Front->m_Next;
	queue->m_Front->m_Next = tmp->m_Next;
	free(tmp);
	tmp = NULL;
	queue->m_Size--;
}

返回队头

int L_Front(Queue* queue)	//返回队头
{
	assert(!L_IsEmpty(queue));
	return queue->m_Front->m_Next->m_Data;
}

返回队头并出队

int L_FrontAndDequeue(Queue* queue)	//返回队头并出队
{
	assert(!L_IsEmpty(queue));
	Node* tmp = queue->m_Front->m_Next;
	int data = tmp->m_Data;
	queue->m_Front->m_Next = tmp->m_Next;
	free(tmp);
	tmp = NULL;
	queue->m_Size--;
	return data;
}

清空队列

void L_MakeEmpty(Queue* queue)	//清空队列
{
	Node* position = queue->m_Front->m_Next;
	queue->m_Front->m_Next = NULL;
	while (position) {
		Node* tmp = position->m_Next;
		free(position);
		position = tmp;
	}
	queue->m_Rear = queue->m_Front;
	queue->m_Size = 0;
}

删除队列

Queue* L_DisposeQueue(Queue* queue)	//删除队列
{
	Node* position = queue->m_Front;
	queue->m_Rear = NULL;
	while (position) {
		Node* tmp = position->m_Next;
		free(position);
		position = tmp;
	}
	free(queue);
	queue = NULL;
	return queue;
}

数组实现

通过循环数组实现队列。

数组队列的定义

typedef struct QueueArray
{
	size_t m_Capacity;	//容量
	size_t m_Size;	//元素个数
	size_t m_Front;	//对头
	size_t m_Rear;	//队尾
	int* m_Array;	//数组
}QueueArray;

循环判定

//队尾和队头循环
inline size_t A_Circulation(size_t position, QueueArray* queue)
{
	if (++position == queue->m_Capacity) {
		position = 0;
	}
	return position;
}

判断是否为空

//判断队列是否为空
inline bool A_IsEmpty(QueueArray* const queue)
{
	return queue->m_Size == 0;
}

判断是否为满

//判断队列是否为满
inline bool A_IsFull(QueueArray* const queue)
{
	return queue->m_Size == queue->m_Capacity;
}

创建队列

//创建一个队列
QueueArray* A_CreateQueue(const size_t capacity)
{
	QueueArray* queue = (QueueArray*)malloc(sizeof(QueueArray));
	if (!queue) {
		return NULL;
	}
	queue->m_Array = (int*)malloc(sizeof(int) * capacity);
	if (!queue) {
		return NULL;
	}
	queue->m_Capacity = capacity;
	queue->m_Size = 0;
	queue->m_Front = 1;
	queue->m_Rear = 0;
	return queue;
}

入队

//入队
void A_Enqueue(int data, QueueArray* queue)
{
	assert(!A_IsFull(queue));
	queue->m_Rear = A_Circulation(queue->m_Rear, queue);
	queue->m_Array[queue->m_Rear] = data;
	queue->m_Size++;
}

出队

//出队
void A_Dequeue(QueueArray* queue)
{
	assert(!A_IsEmpty(queue));
	queue->m_Front = A_Circulation(queue->m_Front, queue);
	queue->m_Size--;
}

返回队头

//返回队头
int A_Front(QueueArray* queue)
{
	assert(!A_IsEmpty(queue));
	return queue->m_Array[queue->m_Front];
}

返回队头并出列

//返回对头并出队
int A_FrontAndDequeue(QueueArray* queue)
{
	assert(!A_IsEmpty(queue));
	int data = queue->m_Array[queue->m_Front];
	queue->m_Front = A_Circulation(queue->m_Front, queue);
	queue->m_Size--;
	return data;
}

清空队列

//清空队列
void A_MakeEmpty(QueueArray* queue)
{
	queue->m_Front = 1;
	queue->m_Rear = 0;
	queue->m_Size = 0;
}

删除队列

//删除队列
QueueArray* A_DisposeQueue(QueueArray* queue)
{
	free(queue->m_Array);
	free(queue);
	queue = NULL;
	return queue;
}