算法导论-优先级队列

//优先级队列
//堆的一个很常见的应用：作为高效的优先级队列（priority queue）。
//优先级队列和堆一样有二种：最大优先级队列和最小优先级队列, 优先级队列是一种维护由一组元素构成的集合S的数据结构，这一组元素中的每一个都有一个关键字key一个最大优先级队列支持下面的操作：
/*1:INSERT(S,x):把元素x插入集合S中。
 *2：MAXIMUM(S):返回S中具有最大关键字的元素。
 3：EXTRACT_MAY(S):去掉并返回S中具有最大关键字的元素。
 4：INCREASE_KEY(S,x,k):将元素x的关键字的值加到k，这里的k值不能小于x的原来的关键字的值。
 5：DELETE(S,x):将节点x从集合中移除
EX:最大优先级队列的一个应用是在一台分时的计算机上进行作业调度。这种队列对要执行的各种作业以及它们之间的相对优先级加以记录。当一个作业完成被中断时，用EXTRACT_MAX操作从所有等待的作业中，选择出具有最高优先级的作业。在任何的时候，一个新的作业可以用INSERT加入到队列中去。
*/
//最大堆实现的最大优先级队列。
#include "stdio.h"
#include "stdlib.h"
#define MAX 255
#define INFINITELY_SMALL -2000000000
typedef struct {
		int array[MAX];
		int length;
}Array;


int HEAP_INCREASE_KEY (Array *a,int i,int key) {
		if (key < a->array[i]) {
				printf ("新的关键字的值必须大于当前要改变关键字值");
				return -1;
		}else {
				int parent;
				a->array[i] = key;
				while (i > 1 && a->array[(parent = i / 2)] <a->array[i]) {
						int t = a->array[i];
						a->array[i] = a->array[parent];
						a->array[parent] = t;
						i = parent;
				}
		}
		return 1;
}


int HEAP_INSERT (Array *a,int key) {
		if (a->length >= MAX) {
				printf ("overflow");
				return -1;
		}
		a->array[++a->length] = INFINITELY_SMALL;
		HEAP_INCREASE_KEY (a,a->length,key);
}


int HEAP_MAXIMUM (Array *a) {
		return a->array[1];
}

void MAX_HEAPIFY (Array *a,int i) {
		int j = i,l,r;
		while ((l = i << 1) <= a->length) {
				if (a->array[l] > a->array[j]) {
						j = l;
				}
				r = l + 1;
				if (r <= a->length && a->array[r] > a->array[j]) {
						j = r;
				}
				if (i == j) {
						break;
				}else {
						int t = a->array[i];
						a->array[i] = a->array[j];
						a->array[j] = t;
						i = j;
				}
		}
}

int HEAP_EXTRACT_MAX (Array *a) {
		if (a->length < 1) {
				printf ("the queue is empty!");
				return -1;
		}else {
				int returned = a->array[1];
				a->array[1] = a->array[a->length--];
				MAX_HEAPIFY (a,1);
				return returned;
		}
}


int HEAP_DELETE (Array *a,int i) {
	int returned = a->array[i];
	a->array[i] = a->array[a->length--];
	MAX_HEAPIFY (a,i);
	return returned;
}

void print (Array *a) {
		int i;
		for (i = 1;i <= a->length;i++) {
				printf ("%d ",a->array[i]);
		}
		printf ("\n");
}
int main () {
		Array a;
		int i;
		int ans;
		a.length = 0;
		//构建最大优先级队列
		for (i = 1;i <= 9;i++) {
				HEAP_INSERT (&a,i);
		}
		print (&a);
		//去掉并返回a中具有最大关键字的元素。
		ans = HEAP_EXTRACT_MAX (&a);
		printf ("%d\n",ans);
		print (&a);
		//第a.length个元素关键字增加到100
		HEAP_INCREASE_KEY (&a,a.length,100);
		print (&a);
		//删除第4个元素
		HEAP_DELETE (&a,4);
		print (&a);
		return 0;
}
//output:
/*
9 8 6 7 3 2 5 1 4 
9
8 7 6 4 3 2 5 1 
100 8 6 7 3 2 5 4 
100 8 6 4 3 2 5 
*/

2013-8-30 16：16更新：

上面的HEAP_DELETE方法实现少考虑A[i] >= A[parent(i)]的情况，而只考虑了A[i] < A[parent(i)]的情况。

修改为：

int HEAP_DELETE (Array *a,int i) {
	int returned = a->array[i];
	int key;
	key = a->array[i] =  a->array[a->length--];
	if (i < 2 || key <= a->array[i / 2]) {
		MAX_HEAPIFY (a,i);
	}else {
		while (i > 1 && a->array[i / 2] < key) {
			a->array[i] = a->array[i / 2];	
			i = i / 2;
		}
		a->array[i] = key;		
	}
	return returned;
}

对HEAP_INCREASE_KEY方法进行了一些简化：

int HEAP_INCREASE_KEY (Array *a,int i,int key) {
		if (key < a->array[i]) {
				printf ("新的关键字的值必须大于当前要改变关键字值");
				return -1;
		}else {
				int parent;
				while (i > 1 && a->array[(parent = i / 2)] < key) {
						a->array[i] = a->array[parent];
						i = parent;
				}
				a->array[i] = key;
		}
		return 1;
}