数据结构学习笔记5之特殊表结构（队列）

队列：一个端口进，另一个端口出，先进先出
顺序队列：
由一维数组+队头位置front+队尾位置rear组成，入队时rear+1,出队时front+1，为了让队列能反复使用，我们要把一维数组相像成一个环，因此rear和front加1后要用队列的容量求余。
rear = rear+1 % cal
front = frone+1 % cal

​ 如何判断队列为空：front == rear
​ 如何判断队列为满：front == rear+1
​ 代价就是空一个位置不能用，或者添加一个数据项标记队列为空或满。
​ 如何计算元素的数量：
​ (read-front+cal)%cal

​ 数据项：
​ 存储元素的内存首地址
​ 容量
​ 队头
​ 队尾 即将入队的位置
​
​ 运算：创建、销毁、入栈、出栈、队空、队满、队头、队尾、元数数量

​ 链式队列：
​ 由若干个节点组成的队列。
​ 数据项：
​ 队头指针
​ 队尾指针
​ 节点数量
​ 运算：创建、销毁、队空、入队、出队、队头、队尾、数量

​ 队列应用：
​ 1、消息排队
​ 2、树的层序遍历
​ 3、图的广度优先遍历
​ 4、封装线程池、数据池

​ 常见的笔试面试题：
​ 使用两个栈来模拟一个队列的功能。
​ 从栈1到栈2一个不留
​ 栈2不空栈1不到栈2

顺序队：

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

#define TYPE int

// 序顺队列结构
typedef struct ArrayQueue
{
	TYPE* ptr;
	size_t cal;
	size_t front;
	size_t rear;
}ArrayQueue;

// 创建
ArrayQueue* create_array_queue(size_t cal)
{
	ArrayQueue* queue = malloc(sizeof(ArrayQueue));
	queue->ptr = malloc(sizeof(TYPE)*cal+1);
	queue->cal = cal+1;
	queue->front = 0;
	queue->rear = 0;
	return queue;
}

// 销毁
void destory_array_queue(ArrayQueue* queue)
{
	free(queue->ptr);
	free(queue);
}

// 队空
bool empty_array_queue(ArrayQueue* queue)
{
	return queue->front == queue->rear;
}

// 队满
bool full_array_queue(ArrayQueue* queue)
{
	return (queue->rear+1)%queue->cal == queue->front;
}

// 入队
bool push_array_queue(ArrayQueue* queue,TYPE val)
{
	if(full_array_queue(queue)) return false;
	queue->ptr[queue->rear] = val;
	queue->rear = (queue->rear+1)%queue->cal;
	return true;
}

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

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

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

// 数量
size_t size_array_queue(ArrayQueue* queue)
{
	return (queue->rear-queue->front+queue->cal)%queue->cal;
}


int main(int argc,const char* argv[])
{
	ArrayQueue* queue = create_array_queue(10);
	for(int i=0; i<10; i++)
	{
		push_array_queue(queue,i);
		printf("%d\n",tail_array_queue(queue));
	printf("------------------%d\n",size_array_queue(queue));
	}
	while(!empty_array_queue(queue))
	{
		printf("%d\n",head_array_queue(queue));
		pop_array_queue(queue);
	printf("------------------%d\n",size_array_queue(queue));
	}
	for(int i=0; i<10; i++)
	{
		push_array_queue(queue,i);
		printf("%d\n",tail_array_queue(queue));
	printf("------------------%d\n",size_array_queue(queue));
	}
	destory_array_queue(queue);
}

链式队：

#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 val)
{
	Node* node = malloc(sizeof(Node));
	node->data = val;
	node->next = NULL;
	return node;
}

// 链式队列
typedef struct ListQueue
{
	Node* head;
	Node* tail;
	size_t size;
}ListQueue;

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

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

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

// 出队
bool pop_list_queue(ListQueue* queue)
{
	if(empty_list_queue(queue)) return false;
	Node* temp = queue->head;
	queue->head = temp->next;
	queue->size--;
	free(temp);
	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->size;
}

// 销毁
void destory_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);
		printf("%d\n",tail_list_queue(queue));
	printf("-----------------%d\n",size_list_queue(queue));
	}
	while(!empty_list_queue(queue))
	{
		printf("%d\n",head_list_queue(queue));
		pop_list_queue(queue);
	printf("-----------------%d\n",size_list_queue(queue));
	}
	destory_list_queue(queue);
}