数据结构中队列的存储和应用

队列：

        只有两个口进出数据，一个专门进入数据，另一个专门出数据，先进先出，FIFO表

   

  一、  顺序队列：

        存储元素的连续内存的首地址

        容量

        队头位置    (出队)

        队尾位置    (入队)

        [元素数量]

        运算：创建、销毁、清空、出队、入队、队空、队满、队头、队尾、元素数量

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define TYPE int

//	顺序队列结构
typedef struct ArrayQueue
{
	TYPE* ptr;
	size_t cal;		//	容量
	size_t front;	//	队头位置head\begin
	int rear;	//	队尾位置tail\back int rear = -1
	size_t cnt;		//	数量
}ArrayQueue;

//	创建顺序队列
ArrayQueue* create_array_queue(size_t cal)
{
	//	申请队列结构内存
	ArrayQueue* queue = malloc(sizeof(ArrayQueue));
	//	申请存储队列元素的内存
	queue->ptr = malloc(sizeof(TYPE)*cal);
	//	初始化容量
	queue->cal = cal;

	queue->front = 0;
	queue->rear = -1;
	queue->cnt = 0;
	return queue;
}

//	销毁
void destroy_array_queue(ArrayQueue* queue)
{
	free(queue->ptr);
	free(queue);
}
//	队空
bool empty_array_queue(ArrayQueue* queue)
{
	return 0 == queue->cnt;
}

//	队满
bool full_array_queue(ArrayQueue* queue)
{
	return queue->cal == queue->cnt;	
}

//	入队
bool push_array_queue(ArrayQueue* queue,TYPE data)
{
	if(full_array_queue(queue)) return false;

	queue->rear = (queue->rear+1)%queue->cal;
	queue->ptr[queue->rear] = data;
	queue->cnt++;
	return true;
}

//	出队
bool pop_array_queue(ArrayQueue* queue)
{
	if(empty_array_queue(queue)) return false;
	queue->front = (queue->front+1)%queue->cal;
	queue->cnt--;
	return true;
}

//	队头
TYPE head_array_queue(ArrayQueue* queue)
{
	return queue->ptr[queue->front];	
}

//	队尾
TYPE tail_array_queue(ArrayQueue* queue)
{
	return queue->ptr[queue->rear];	
}

//	数量
size_t size_array_queue(ArrayQueue* queue)
{
	return queue->cnt;
}

int main(int argc,const char* argv[])
{
	ArrayQueue* queue = create_array_queue(5);
	for(int i=0; i<10; i++)
	{
		push_array_queue(queue,i+1) && printf("tail:%d size:%d\n",
			tail_array_queue(queue),size_array_queue(queue));
	}

	printf("-----------------\n");
	while(!empty_array_queue(queue))
	{
		printf("front:%d size:%d\n",
			head_array_queue(queue),size_array_queue(queue));
		pop_array_queue(queue);
	}
	printf("size=%d\n",size_array_queue(queue));

	destroy_array_queue(queue);
	queue = NULL;
}

        需要注意的问题

        1、存储元素是由一维数组+队头位置front+队尾位置rear来表示，入队rear+1,出队front+1，为了让队列能够反复使用，我们需要把一维数组想象成一个环，因此+1后都需要对容量cal求余

            front = (front+1)%cal

            rear = (rear+1)%cal

       

        2、判断队空和队满问题

            如果不处理该问题，那么队空和队满的条件都是 front==rear，就无法区分是队空还是队满

            方法1：存储元素的内存多增加一个位置空间(常考)

                队空：front==rear

                队满：(rear+1)%cal == front

                代价：需要额外申请存储一个元素的内存

                计算数量：(rear-front+cal)%cal

                队尾数据下标：(rear-1+cal)%cal

            方法2：顺序队列结构中增加一个记录元素数量的数据项，通过数量与容量对比判断队空、队满

   

  二、

  链式队列：

        由若干个节点组成的队列结构，只能操作队头节点、队尾节点

        链式队列结构：

            队头指针

            队尾指针

            节点数量

        运算：创建、销毁、队空、入队、出队、队头、队尾、数量

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define TYPE int

//	节点结构
typedef struct Node
{
	TYPE data;
	struct Node* next;
}Node;

//	创建节点
Node* create_node(TYPE data)
{
	Node* node = malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	return node;
}

//	设计链式队列结构
typedef struct ListQueue
{
	Node* head;	//	队头指针
	Node* tail;	//	队尾指针
	size_t cnt;	//	节点数量
}ListQueue;

//	创建队列
ListQueue* create_list_queue(void)
{
	ListQueue* queue = malloc(sizeof(ListQueue));
	queue->head = NULL;
	queue->tail = NULL;
	queue->cnt = 0;
	return queue;
}


//	队空
bool empty_list_queue(ListQueue* queue)
{
	return 0 == queue->cnt;
}

//	入队
void push_list_queue(ListQueue* queue,TYPE data)
{
	Node* node = create_node(data);
	if(0 == queue->cnt)
	{
		queue->head = node;
		queue->tail = node;
	}
	else
	{
		queue->tail->next = node;
		queue->tail = node;
	}
	queue->cnt++;
}

//	出队
bool pop_list_queue(ListQueue* queue)
{
	if(empty_list_queue(queue))	 return false;
	Node* temp = queue->head;
	queue->head = temp->next;
	free(temp);
	queue->cnt--;
	if(0 == queue->cnt) queue->tail = NULL;
	return true;
}

//	队头
TYPE head_list_queue(ListQueue* queue)
{
	return queue->head->data;
}

//	队尾
TYPE tail_list_queue(ListQueue* queue)
{
	return queue->tail->data;
}

//	数量
size_t size_list_queue(ListQueue* queue)
{
	return queue->cnt;
}

//	销毁队列
void destroy_list_queue(ListQueue* queue)
{
	while(pop_list_queue(queue));
	free(queue);
}

int main(int argc,const char* argv[])
{
	ListQueue* queue = create_list_queue();
	for(int i=0; i<10; i++)
	{
		push_list_queue(queue,i+10);
		printf("tail:%d,size:%u\n",
			tail_list_queue(queue),size_list_queue(queue));
	}
	printf("-------------\n");
	while(!empty_list_queue(queue))
	{
		printf("head:%d,size:%u\n",
			head_list_queue(queue),size_list_queue(queue));
		pop_list_queue(queue);
	}
	destroy_list_queue(queue);
	queue = NULL;
}

           

    队列的应用：

        1、数据排队处理-消息排队

        2、树的层序遍历

        3、图的广度优先遍历BFS

        4、封装线程池、数据池