算法导论-优先级队列

//优先级队列
//堆的一个很常见的应用：作为高效的优先级队列（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;
}