数据结构之优先队列（线性结构的优先队列，数组实现和链表实现）

优先队列(priority queue)

普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出 （first in, largest out）的行为特征

优先队列是0个或多个元素的集合,每个元素都有一个优先权或值,对优先队列执行的操作有1) 查找;2) 插入一个新元素;3) 删除.在最小优先队列(min priority queue)中,查找操作用来搜索优先权最小的元素,删除操作用来删除该元素;对于最大优先队列(max priority queue),查找操作用来搜索优先权最大的元素,删除操作用来删除该元素.优先权队列中的元素可以有相同的优先权,查找与删除操作可根据任意优先权进行.

优先队列经常通过堆的方式来实现，查找和删除的时间复杂度都是log2n，所以很快

另一种描述方法是采用有序线性表,当元素按递增次序排列,使用链表时则按递减次序排列,这两种描述方法的删除时间均为( 1 ),插入操作所需时间为(n).

基础概念就是这么些了，因为我现在总结的是线性结构，所以我们来用线性的结构实现这个数据结构

我先来用数组的方式来实现一下
我来引进一个问题，任务调度问题，进程i需要pr_i的时间，求各任务等待的时间加起来最小的排序

下面是我的测试数据文件：

基础概念里面说到，数据都有优先级，所以我们就想到了，数据就分为了两部分：数据本身，优先权。
所以我们将它封装成一个结构体：

struct data {
	int num;
	int prior;//优先权
};

接下来是优先队列这个数据结构的结构体封装，我们实现的是数组的优先队列，它和数组队列有一样的性质，那么就是下面这样的结构：

struct prqueue {
	struct data datanum[MAX];
	int size;
};

创建优先队列的函数：其实就是数组的初始化和大小的初始化

struct prqueue* createqueue() {
	struct prqueue* newqueue = (struct prqueue*)malloc(sizeof(struct prqueue));
	newqueue->size = 0;
	memset(newqueue->datanum, 0, sizeof(data) * MAX);
	return newqueue;
}

接下来是查询队列是否为空：

bool isempty(struct prqueue* pqueue) {
	return pqueue->size == 0;
}

接下来是入队操作，也就是数组队列的常规入队：

void push(struct prqueue* pqueue, struct data pdata) {
	if (pqueue->size + 1 == MAX) {
		printf("队满无法入队");
		return;
	}//数组是要判断一下队满的情况的
	pqueue->datanum[pqueue->size].num = pdata.num;
	pqueue->datanum[pqueue->size].prior = pdata.prior;
	pqueue->size++;
}

出队的操作，删除和写入变量的函数，我们利用传入一级指针来读取数据：
优先队列出队出去的是优先级最高的数，我这里权值最小的就是我们所需要的优先级最高的
所以就是找到最小的权值的数据：

void pop(struct prqueue* pqueue, struct data* pdata) {
	if (isempty(pqueue)) {
		printf("队为空，无法出队");
		return;
	}
	int minindex = 0;
	struct data mind = pqueue->datanum[0];
	for (int i = 1; i < pqueue->size; i++) {
		if (mind.prior > pqueue->datanum[i].prior) {
			mind = pqueue->datanum[i];
			minindex = i;
		}
	}//选择排序，找到优先级最小的
	pdata->num = mind.num;
	pdata->prior = mind.prior;
	for (int i = minindex; i < pqueue->size; i++) {
		pqueue->datanum[i] = pqueue->datanum[i + 1];
	}//伪删除，所删除的元素后面的数组集体往前移动
	pqueue->size--;
}

接下来是主函数来实现上面的问题排序

int main() {
	struct prqueue* pqueue = createqueue();
	struct data readdata;
	FILE* fp = fopen("test.txt", "r");
	if (fp == NULL) {
		printf("无法打开文件夹");
		return 0;
	}
	while (fscanf(fp, "%d %d\n", &readdata.num, &readdata.prior) != EOF){
		push(pqueue, readdata);
	}
	fclose(fp);
	int workindex = 1;
	while (!isempty(pqueue)) {
		pop(pqueue, &readdata);
		printf("\t%d\t%d\t%d\n", workindex, readdata.num, readdata.prior);
		workindex++;
	}
	return 0;
}

以下是结果：

我上面提到，线性结构可以实现优先队列，那么除了数组，是不是还有一种结构？
对，链表，让我们来看一下，用链表来实现这个问题的优先队列

首先就是节点和优先队列的链表结构体实现和创建：
我用的是双向链表，因为这样在插入的时候根据优先级自动选择插入更加方便（但是随之而来容易出现异常和bug）

struct node {
	struct node* front;
	struct data ndata;
	struct node* next;
};//双向链表的节点的结构体
struct listpriqueue {
	struct node* headnode;
	struct node* tailnode;
	int size;
};//链式优先队列的结构体
bool isempty(struct listpriqueue* plist) {
	return plist->size == 0;
}//判断是否为空的万金油函数
struct node* createnode(struct data pdata) {
	struct node* newnode = (struct node*)malloc(sizeof(struct node));
	newnode->next = newnode->front = NULL;
	newnode->ndata = pdata;
	return newnode;
}//创建新节点，初始化新节点
struct listpriqueue* creatlistpriqueue() {
	struct listpriqueue* newqueue = (struct listpriqueue*)malloc(sizeof(struct listpriqueue));
	newqueue->headnode = newqueue->tailnode=NULL;
	newqueue->size = 0;
	return newqueue;
}//初始化新链式优先队列并创建返回

接下来是重头戏，就是链式优先队列的插入，依照优先级插入，也就是双向链表的索引插入法，这里只不过运用了比较的方式找到合适点插入：

void push(struct listpriqueue* plist, struct data pdata) {
	struct node* newnode = createnode(pdata);
	if (isempty(plist)) {
		plist->headnode = plist->tailnode = newnode;
	}
	//这里一定要分好情况，要不然各种指针指向NULL，或者是出不来数据，死循环问题，小心，一定要理解我下面的东西
	else {
		struct node* pmove = plist->headnode;
		while (pmove != plist->tailnode) {
			if (newnode->ndata.prior < pmove->ndata.prior && pmove == plist->headnode) {//当比头节点还小，也就是，要插入的数据优先级最大的时候，就是头节点插入法
				newnode->next = plist->headnode;
				plist->headnode->front = newnode;
				plist->headnode = newnode;
			}
			if (newnode->ndata.prior < pmove->ndata.prior) {//在中间的的位置找到了，就是双向链表的合适位置插入，可以参照我之前的博客
				newnode->front = pmove->front;
				pmove->front->next = newnode;
				newnode->next = pmove;
				pmove->front = newnode;
				break;
			}
			pmove = pmove->next;//一定要移动，要不然插入的是个屁，我就这里没表示，然后一直给我抛异常，我就好久才发现
		}
		if (pmove == plist->tailnode) {//当没找到合适位置，意味着，优先级最小，就是尾结点插入法
			newnode->front = plist->tailnode;
			plist->tailnode->next = newnode;
			newnode->next = NULL;
			plist->tailnode = newnode;
		}
	}
	plist->size++;
}

接下来就是出队操作，就是平常的链式队列出队，也就是头节点删除法：

void pop(struct listpriqueue* plist, struct data* pdata) {
	if (isempty(plist)) {
		printf("队为空，无法出栈");
		return;
	}
	*pdata = plist->headnode->ndata;
	struct node* deletenode = plist->headnode;
	if (plist->size == 1) {
		free(deletenode);
		plist->headnode = NULL;
	}
	else {
		plist->headnode = plist->headnode->next;
		free(deletenode);
	}
	plist->size--;
}

啊，这时候，屏幕面前一定有长得非常帅的小伙子问了哈，为什么你数组那里要出队的时候实现优先级最大出列，到这就成了入队的时候优先级在前了呢。
我来分析一波，插入的时候是不是找到合适位置就可以停下来了，而出队的时候需要扫描完才能确定，所以，插入实现优先最好情况是O（1）最坏情况是O(n)，但是出队实现优先的是O(n)，不管是不是最坏还是最好（排好的情况），所以，某种意义上是插入的时候实现最好。

下面是主函数来实现上面的问题：

int main() {
	struct listpriqueue* pqueue = creatlistpriqueue();
	struct data readdata;
	FILE* fp = fopen("test.txt", "r");
	if (fp == NULL) {
		printf("无法打开文件夹");
		return 0;
	}
	while (fscanf(fp, "%d %d\n", &readdata.num, &readdata.prior) != EOF){
		push(pqueue, readdata);
	}
	fclose(fp);
	int workindex = 1;
	while (!isempty(pqueue)) {
		pop(pqueue, &readdata);
		printf("\t%d\t%d\t%d\n", workindex, readdata.num, readdata.prior);
		workindex++;
	}
	return 0;
}

好了线性的优先队列就到这了。