数据结构：线性结构(3)

第三节

队列：队列也是功能受限的表，和栈不同的是，队列有两个端口控制数据的进出，这就导致了队列先进先出的特点，队列也分顺序队列和链式队列
队列可用于树的层序遍历和图的广度遍历
下面是顺序队列的运算

typedef struct QueueArray
{
	TYPE* arr;
	size_t len;
	size_t cnt;
	int head;
	int tail;
}QueueArray;

// 创建
QueueArray* create_queue_array(size_t len)
{
	QueueArray* queue = malloc(sizeof(QueueArray));
	queue->arr = malloc(sizeof(TYPE)*len);
	queue->len = len;
	queue->cnt = 0;
	queue->head = 0;
	queue->tail = -1;
	return queue;
}

// 销毁
void destory_queue_array(QueueArray* queue)
{
	free(queue->arr);
	free(queue);
}

// 队空
bool empty_queue_array(QueueArray* queue)
{
	return !queue->cnt;
}

// 队满
bool full_queue_array(QueueArray* queue)
{
	return queue->cnt >= queue->len;
}

// 入队
bool push_queue_array(QueueArray* queue,TYPE data)
{
	if(full_queue_array(queue))	return false;
	queue->tail = queue->tail+1 % queue->len;
	queue->arr[queue->tail] = data;
	queue->cnt++;
	return true;
}

// 出队
bool pop_queue_array(QueueArray* queue)
{
	if(empty_queue_array(queue)) return false;
	queue->head = queue->head + 1 % queue->len;
	queue->cnt--;
	return true;
}

// 队头
TYPE* head_queue_array(QueueArray* queue)
{
	if(empty_queue_array(queue)) return NULL;
	return queue->arr + queue->head;
}

// 队尾
TYPE* tail_queue_array(QueueArray* queue)
{
	if(empty_queue_array(queue)) return NULL;
	return queue->arr + queue->tail;
}

下面是链式队列的运算

typedef struct Queue
{
	Node* top;
	size_t len;
}Queue;
#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 Queue
{
	Node* head;
	Node* tail;
}Queue;

// 创建队列
Queue* create_queue(void)
{
	Queue* queue = malloc(sizeof(Queue));
	queue->head = NULL;
	queue->tail = NULL;
	return queue;
}

// 队空
bool empty_queue(Queue* queue)
{
	return NULL == queue->head;
}

// 入队
void push_queue(Queue* queue,TYPE data)
{
	Node* node = create_node(data);
	if(empty_queue(queue))
	{
		queue->head = node;
		queue->tail = node;
	}
	else
	{
		queue->tail->next = node;
		queue->tail = node;
	}
}

// 出队
bool pop_queue(Queue* queue)
{
	if(empty_queue(queue)) return false;
	Node* temp = queue->head;
	queue->head = temp->next;
	free(temp);
	return true;
}

// 队头
bool head_queue(Queue* queue,TYPE* p)
{
	if(empty_queue(queue)) return false;
	*p = queue->head->data;
	return true;
}

// 队尾
bool tail_queue(Queue* queue,TYPE* p)
{
	if(empty_queue(queue)) return false;
	*p = queue->tail->data;
	return true;
}

// 销毁队
void destory_queue(Queue* queue)
{
	while(!empty_queue(queue))
	{
		pop_queue(queue);
	}
	free(queue);
}

进行出队操作时仅需移动队头
进行入队操作时仅需移动队尾
可以使用两个栈来实现队列的功能
也可以使用两个队列来实现栈的功能