数据结构之队列

队列的概念

队列(queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表

两种队列的实现

1.静态队列

利用一个定长数组作为队列的存储空间，确定一个指向开头数据下标的变量head以及一个指向最后一个数据的下表的tail

操作中

入队时：如果队列中仍然有存储空间tail加一将数据插入队列尾部，如果tail大于数组长度MAX_SIZE-1则将tail指向0

出队时：如果队列不为空则将head下表指向的数据返回，并将head加一，如果head大于MAX_SIZE-1则将head指向0

数据结构：

typedef struct ls//数组实现的静态队列
{
	int buffer[MAX_SIZE];
	int head = 0;//头指针
	int tear = -1;//尾部指针
	int count = 0;//元素个数
}Queue;

count用于计数，这样不在需要计算队列中含有元素的个数了

进队列操作：

bool EnQueue(Queue* Qu,int date)//静态队列入
{
	if (Qu->count > MAX_SIZE)return 0;//数据满了返回0
	if (++Qu->tear > MAX_SIZE - 1)Qu->tear = 0;//尾部溢出则指向头部
	Qu->buffer[Qu->tear] = date;
	Qu->count++;
	return	1;
}

count大于MAX_SIZE则表示队列中已经没有多余的存储空间了 返回0

出队列操作：

bool DeQueue(Queue* Qu, int *date)//静态队列出
{
	if (Qu->count == 0)return 0;//空队列返回0
	if (++Qu->head > MAX_SIZE - 1)Qu->head = 0;
	Qu->count--;
	return 1;
}

count=0时则表示该队列为空，返回0

总结：该方式下入队和出队均不涉及循环所以时间复杂度为O(1)但是内存空间分配非常不灵活，可能出现浪费或者不够用的情况，所以为了解决这种情况下的问题，使用后一种队列形式：链队列。

2.链队列

链队列利用线性链表的特点，可以实现动态增加或者减少队列占用的内存，使内存的分配更加灵活。

需要一个指向队列头部的指针head和指向尾部的指针tear，初始化时将这两个指针初始化为NULL

进队列时：如果此时队列为空则为头指针分配存储空间并将值赋值给该空间，尾部指针指向头部指针

    如果此时队列部位空则在尾部指针next指针后面分配存储空间，存储进队列的值，尾部指针tear再指向原tear->next

出队列时：如果此时队列为空即lenth=0返回0

    lenth！=0则返回头指针指向的数据，释放该存储空间，头指针指向原head->next

数据结构

typedef struct item
{
	int data = 0;
	item*next = NULL;
}LinkNode,*NodePtr;

typedef struct elem//需要队列头和队列尾部
{
	NodePtr head = NULL;
	NodePtr tear = NULL;
	int lenth = 0;//队列长度
}LinkQueue;

LinkNode为链表节点

next指针需要初始化为空

LinkQueue为链队列

头指针和尾部指针均需要初始化为空

进队列操作

bool EnQueue(LinkQueue* Qu,int date)//入队列
{
	NodePtr e = (NodePtr)malloc(sizeof(LinkNode));
	e->data = date;
	e->next = NULL;
	if (Qu->tear == NULL)//如果队列为空 也可以判断lenth
	{
		Qu->head = e;
		Qu->tear = e;
		Qu->lenth = 1;
	}
	else
	{
		Qu->tear->next = e;
		Qu->tear = e;
		Qu->lenth++;//长度自加一位
	}
	return 1;
}

操作方法入上所述

出队列操作

bool DeQueue(LinkQueue*Qu, int*date)//出队列
{
	if (Qu->lenth == 0)return 0;//空队列
	NodePtr temp = Qu->head;
	*date = temp->data;
	if (Qu->head == Qu->tear)//也可以判断lenth为0
	{
		Qu->head = NULL;
		Qu->tear = NULL;
	}
	else
	{
		Qu->head = Qu->head->next;
	}
	Qu->lenth--;
	free(temp);
	return 1;
}

总结：这种数据结构可以更为灵活分配内存，只要系统还有剩余内存就可以再往里面添加数据，进队列和出队列与静态队列一样不涉及到循环所以时间复杂度仍然是O(1)