数据结构——队列的链式结构实现

Posted 2021-10-04 aaaaaaaWoLan

文章目录

• 队列
• • 队列的概念及结构
  • 队列的实现——链式结构

队列

队列的概念及结构

大家买过茶颜悦色的话想必就知道排队的队伍是多么庞大了

队列就像我们平时排队的特点一样，排在前面的先买到奶茶。

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出
FIFO(First In First Out，也就是先进先出) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头

队列的实现——链式结构

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数
组头上出数据，效率会比较低。

队列是需要队首和队尾的，所以我们需要考虑一个问题：如何判断队列是否为空？

是判断队首等于队尾吗？还是队首为空？

如果用队首等于队尾判断队列是否为空的话，是不准确的，当队列中只有一个元素时，队首和队尾也相等，可是此时队列并不为空，所以不能用这个来作为判断条件。

所以我们是通过判断队首是否为空来判断队列是否为空。

链式结构的队列

进队：

出队：

Queue.h:

// 链式结构：表示队列
typedef int tp;

typedef struct QueueNode {
	struct QueueNode* next;
		tp data;
}q;

typedef struct Queue {
	q* head;
	q* tail;
}qu;

//初始化队列
void QueueInit(qu* p);

//销毁队列
void QueueDestroy(qu* p);

//插入数据
void QueuePush(qu* p, tp x);

//删除数据
void QueuePop(qu* p);

//返回队首
tp QueueFront(qu* p);

//返回队尾
tp QueueBack(qu* p);

//返回队列大小
tp QueueSize(qu* p);

//判断队列是否为空
bool QueueEmpty(qu* p);

Queue.c：

#include"queue.h"

//将队列初始化
void QueueInit(qu* pq)
{
	assert(pq != NULL);
	pq->head = pq->tail = NULL;
}

//销毁队列
void QueueDestroy(qu* pq)
{
	assert(pq != NULL);
	assert(!QueueEmpty(&pq));

	q* cur = pq->head;
	while (cur != NULL)
	{
		qu* tmp = cur->next;
		free(cur);
		cur = tmp;
		tmp = NULL;
	}
	cur = NULL;
	pq->head = pq->head = NULL;
}

//元素入队尾
void QueuePush(qu* pq, tp x)
{
	assert(pq != NULL);

	q* newnode = (q*)malloc(sizeof(q));
	newnode->data = x;
	newnode->next = NULL;

	if (pq->head == NULL)//空队列时入队要特殊处理
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

//队首元素出队
void QueuePop(qu* pq)
{
	assert(pq != NULL);
	assert(!QueueEmpty(&pq));
	
	if (pq->head == pq->tail)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}

	q*tmp = pq->head->next;
	free(pq->head);
	pq->head = tmp;
}

//返回队首元素
tp QueueFront(qu* pq)
{
	assert(pq != NULL);
	assert(!QueueEmpty(&pq));

	return pq->head->data;
}

//返回队尾元素
tp QueueBack(qu* pq)
{
	assert(pq != NULL);
	assert(!QueueEmpty(&pq));

	return pq->tail->data;
}

//返回队列大小
tp QueueSize(qu* pq)
{
	assert(pq != NULL);
	assert(!QueueEmpty(&pq));
	
	int count = 0;
	q* cur = pq->head;
	while (cur != NULL)
	{
		count++;
		cur = cur->next;
	}

	return count;
}

/
bool QueueEmpty(qu* pq)
{
	assert(pq != NULL);

	return pq->head == NULL;
}

另外扩展了解一下，实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型
时可以就会使用循环队列。环形队列可以使用数组实现，也可以使用循环链表实现。