数据结构 --- 队列

队列

1. 概念与结构

1.1 概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的线性表，因此队列具有先进先出、后进后出的特点。、

队头：进行删除/出队的一端。
队尾：进行插入/入队的一端。

1.2 结构的选择

队列的结构应该如何选型呢？应该选择**顺序结构（数组）还是链式结构（单链表）**呢?
方案一：选择数组
那这里还有一个问题，**哪里是队头、哪里是队尾呢？**这里我们假设队头在左，队尾在右。

经过顺序表的学习，我们知道出队（顺序表头删）的时间复杂度为O(n)，入队（顺序表尾插）的时间复杂度为O(1)。那么是时间复杂度最好的结构嘛？我们把队头和队尾兑换位置试试看。

这样的结构实现队列是不合理的，假设我们数组申请了6个元素空间大小的数组，这样我们就面临了几个问题，入队和出队无法使用size，需要额外的定义一个变量，队满扩容后队列的数据需要整体向后移动，甚至入/出队要定义的变量也需要改变，否则无法正确的入队，这样的结构实现起来是非常复杂的，我们考虑通过这个结构来实现队列。
方案二：使用链表（单链表）

假设是这样的结构，入队（单链表的头插）时间复杂度为O(1),出队（单链表的尾删）时间复杂度为O(n)。

假设是上图这样的结构,入队（单链表的尾插）时间复杂度为O(n),出队（单链表的头删）时间复杂度为O(1)。
看来使用链表的时间复杂度和使用数组的时间复杂度类似，最多可以做到一个为O(1)，另一个为O(1)，那**我们能不能把链表的时间复杂度全部都做到O(1)呢？**以链表的第二种假设为例：

这种结构是入队的时间复杂度为O(n)，因为我们需要遍历找到链表的队尾元素。所以我们在以上的结构上做一些小小的改动。

我们定义了两个指向指针，一个指向队头，一个指向队尾，这样入队的时候就不需要找到遍历找队尾了，这样入队/出队的时间复杂度都可以做到O(1)。下面我们就要使用这种结构来实现队列。

2.队列的实现

2.1定义队列的结点结构

typedef int QDataType;
typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
};

这里队列的是使用单链表来实现的，所以队列的结点结构和单链表的结点结构一样。

2.2定义队列的结构

typedef struct Queue
{
	struct QueueNode* QHead;
	struct QueueNode* QTail;
	int size;
};

这里定义的队列结构实际就是定义了两个指向队列头尾结点的指针，就是这两个指针实现了入队列和出队列的时间复杂度均为O(1)，size是队列中有效元素的个数，定义size可以简化部分函数的实现。

2.3 队列的初始化

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->pHead = NULL;
	pq->pTail = NULL;
	pq->size = 0;
}

这里把队列结构的头尾指针全部都置为NULL,并把size置为0，表示队列中没有任何一个元素。

2.4 入队列

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QDataType* newnode = (QDataType*)malloc(sizeof(QDataType));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	if (pq->pHead == NULL)
	{
		pq->pHead = pq->pTail = newnode;
	}
	else
	{
		pq->pTail->next = newnode;
		pq->pTail = pq->pTail->next;
	}
	pq->size++;
}

入队列之前首先要创建一个结点并把结点的data和next初始化一下，入队的时候要考虑到两种情况，一：队列为空，队头和队尾指针都要指向该结点，二：队列不为空，队头不需要改变，队尾单独改变即可，最后不要忘了size++；

2.5 队列的判空

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->pHead == NULL;
}

队列的判空有多种写法，下面的也是可取的方式。

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->pTail == NULL;
}

2.6 返回队列的有效元素个数

int QueueSieze(Queue* pq)
{
	assert(pq);
	return pq->size;
}

这里我们提出一个问题，**如果我们在队列结构中没有定义size那这个函数该如何实现呢？**对于链式结构中结点个数的统计，那只能遍历实现了，时间复杂度为O(n）并不是一种很好的时间复杂度，当我们定义size后，一键返回即可。

2.7 出队列

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	if (pq->pHead == pq->pTail)
	{
		free(pq->pHead);
		pq->pHead = pq->pTail = NULL;
	}
	else
	{
		QueueNode* next = pq->pHead->next;
		free(pq->pHead);
		pq->pHead = next;
	}
	pq->size--;
}

出队列之前要先判空，然后分情况判断，当队列中只有一个结点的时候，pHead和pTail都置为NULL,当队列中不只一个结点的时候，只需要改变pHead，最后不要忘记size–;

2.8 取队头 && 队尾 数据

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->pHead->data;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->pTail->data;
}

这里说明一点，当队列为空的时候，QueueEmpty返回true,但是assert()的参数为false的时候才会结束程序，这里我们需要把QueueEmpty的结果取反。

2.9 销毁队列

void QueueDestory(Queue* pq)
{
	assert(pq);
	QueueNode* pcur = pq->pHead;
	QueueNode* next = NULL;
	while (pcur != NULL)
	{
		next = pcur->next;
		free(pcur);
		pcur = next;
	}
	pq->pHead = pq->pTail = NULL;
	pq->size = 0;
}

遍历销毁结点即可。
队列是一种限定操作的线性表，这里的队列是单链表来实现的，所以在这里可以称队列是一种限定操作的单链表。

void test()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
    QueuePush(&q, 4);
	QueuePop(&q);
	bool em = QueueEmpty(&q);
	if (em == true)
	{
		printf("为空\n");
	}
	else
	{
		printf("不为空\n");
	}
	//while (QueueSize(&q))
	//{
	//	printf("%d\n", QueueSize(&q));
	//	QueuePop(&q);
	//}
	printf("phead:%d\n", QueueFront(&q));
	printf("ptail:%d\n", QueueBack(&q));
	//QueueDestory(&q);
}

这里给出一个测试函数，大家也可以调试来观察函数的详细执行情况。