基础数据结构和算法——5、队列

基础数据结构和算法——5、队列

1. 队列是什么？

队列是一种只能从表的一端存数据另一端取数据且遵循FIFO(先进先出)原则的线性存储结构。

• 与栈相似，队列是存取受限制的特殊的线性表。
• 在队列的一端只能插入元素，这一端叫做队尾。
• 在队列的另一端只能删除元素，这一端叫做队首。

通常只会对队列执行以下两种操作：

1. 数据元素进队列的过程称为 “入队”
2. 出队列的过程称为 “出队”。

队列与栈的比较

2. 队列怎么用？

队列一般用来处理与等待相关的处理。

3. 队列怎么实现？

考虑到每次出队和入队都要移动队首和队尾指针。若采用顺序存储，将会有可能造成顺序表前段部分存储单元的浪费。虽说可以采用循环队列的方式复用存储单元，若遇到队列满的情况，将队列扩容比较麻烦。因此建议用链表的方式实现队列。

3.1 定义结构

typedef int QueueType;

struct LinkNode{
    QueueType key;
    struct LinkNode *next;
};

typedef struct {
    struct LinkNode *head;//队列的头指针
    struct LinkNode *end;//队列的尾指针
}Queue;

3.2 定义操作

1. 创建队列

Queue queue_create();

2. 访问队首元素

LinkNode* queue_front(Queue* queue);

3. 入队

void queue_push(Queue* queue,QueueType element);

4. 出队

void queue_pop(Queue* queue);

• 完整代码

#include "queue.h"
#include 
#include 
#include 

#ifdef QUE
//创建
Queue queue_create(){
	Queue que = {NULL,0};
	return que;
}
//销毁
void queue_destroy(Queue* que){
	free(que->data);
	que->data = NULL;
	que->size = 0;
}
//入队
void queue_push(Queue* que,QueueType val){
	assert(NULL!=que); //断言
	que->size++;
	que->data = realloc(que->data,que->size*sizeof(QueueType));
	memcpy(que->data+1,que->data,(que->size-1)*sizeof(QueueType));
	que->data[0] = val;
}
//出队
void queue_pop(Queue* que){
	assert(NULL != que);
	assert(que->size > 0);
	que->size--;
}
//获取队首元素
QueueType queue_front(Queue* que){
	assert(NULL != que);
	assert(que->size > 0);
	return que->data[que->size-1];	
}
//判空
bool queue_empty(Queue* que){
	assert(NULL != que);
	return que->size == 0;
}
#endif

#ifdef LINK

//创建
Queue queue_create(){
	Node* dummy = malloc(sizeof(Node));
	dummy->next = NULL;
	Queue que = {dummy,dummy};
	return que;
}
//销毁
void queue_destroy(Queue* que){
	assert(NULL != que);
	Node* p = que->head;
	while(NULL != p){
		Node* del = p;
		p = p->next;
		free(del);
	}
	/*
	que->head = NULL;
	que->tail = NULL;
	*/
	memset(que,0,sizeof(Queue));
}
//入队
void queue_push(Queue* que,QueueType val){
	assert(NULL!=que); //断言
	Node* p =malloc(sizeof(Node));
	p->val = val;
	p->next = NULL;
	//链表尾部入队
	que->tail->next = p;
	que->tail = p;
}
//出队
void queue_pop(Queue* que){
	assert(NULL != que);
	assert(que->tail != que->head);
	//链表头部出队
	Node* del = que->head->next;
	que->head->next = del->next;
	if(NULL == del->next){  //删除最后一个节点
		que->tail = que->head;
	}
	free(del);
}
//获取队首元素
QueueType queue_front(Queue* que){
	assert(NULL != que);
	assert(que->tail != que->head);
	return que->head->next->val;	
}
//判空
bool queue_empty(Queue* que){
	assert(NULL != que);
	return que->head == que->tail;
}

#endif

• 练习

1. 两个栈实现一个队列

2. 两个队列实现一个栈