(五)使用最大堆实现优先级队列

/*******************************************
利用最大堆实现最大优先级队列
最大优先级支持的操作：
1.insert(S,x) //将元素x插入集合S中
2.maximum(S)  //返回S中最大关键字的元素
3.extract(S)  //去掉并返回S中最大关键字的元素
4.increase_key(S,x,k)  //将元素x的关键字的值增加到k，且这里的k不能小于x
=======================================================
伪代码
HEAP_MAXIMUM(A):
    return A[0]
    
HEAP_EXTRACT_MAX(A):
    if heapsize[A]<1
        then error "heap underflow"
    max<——A[0]
    A[0] <——> A[heapsize[A]-1]
    heapsize[A]<—— heapsize[A]-1
    MAX_HEAPIFY(A,0)
    return max

HEAP_INCREASE_KEY(A,i,key)
    if key<A[i]
        then error "key is less than A[i]"
    A[i]<——key
    while i>0 and A[PARENT(i)]<A[i]
        do exchange A[PARENT(i)] <——> A[i]
        i<—— PARENT(i)
//首先将新增元素设置为-∞，再通过调用HEAP_INCREASE_KEY将-∞增加到key         
MAX_HEAP_INSERT(A,key)
    heapsize[A] <—— heapsize[A]+1
    A[heapsize[A]-1] <—— -∞ 
    HEAP_INCREASE_KEY(A,heapsize[A]-1,key)
*******************************************/
#include <stdio.h>
#include <stdlib.h>
#define PARENT(i) (i)/2
#define LEFT(i) 2*(i)+1
#define RIGHT(i) 2*((i)+1)
#define MAX_SIZE 1024
#define MAX_INT ~(1<<31)
#define MIN_INT -MAX_INT-1
typedef struct{
    int *data;
    int size;
}PriorityQ;
void max_heapify(PriorityQ *queue,int index,int len)
{
    int l=LEFT(index);
    int r=RIGHT(index);
    int largest;
    if(l<len && queue->data[l]>queue->data[index])
        largest=l;
    else
        largest=index;
    if(r<len && queue->data[r]>queue->data[largest])
        largest=r;
    if(largest != index){//将最大元素提升，并递归
        int tmp=queue->data[largest];
        queue->data[largest]=queue->data[index];
        queue->data[index]=tmp;
        max_heapify(queue,largest,len);
    }
}
//如果队列为空，则返回MAX_INT
int maximum(PriorityQ *queue)
{
    if(queue->size>0)
        return queue->data[0];
    else
        return MAX_INT;
}
int extract_max(PriorityQ *queue)
{
    if(queue->size<=0)
        return MAX_INT;
    int max=queue->data[0];
    queue->data[0]=queue->data[queue->size-1];
    queue->size--;
    max_heapify(queue,0,queue->size);
    return max;
}
void increase_key(PriorityQ *queue,int index,int key)
{
    if(queue->size <= index || queue->data[index]>key)
        return;
    queue->data[index]=key;
    int tmp;
    while(index>0 && queue->data[PARENT(index)]<queue->data[index]){
        tmp=queue->data[PARENT(index)];
        queue->data[PARENT(index)]=queue->data[index];
        queue->data[index]=tmp;
        index=PARENT(index);
    }
}
void insert(PriorityQ *queue,int key)
{
    if(queue->size>=MAX_SIZE)
        return;
    queue->size++;
    //如果size为1，说明queue只有一个元素，无需调整
    if(queue->size==1){
        queue->data[0]=key;
        return;
    }
    queue->data[queue->size-1]=MIN_INT;
    increase_key(queue,queue->size-1,key);
}
//test
int main()
{
    int arr[10]={1,4,18,2,5,8,7,6,9,12};
    PriorityQ myQueue;
    //开辟优先级队列数据域空间，并将当前队列中元素个数设置为0
    myQueue.data=(int*)malloc(1024*sizeof(int));
    myQueue.size=0;
    int i;
    for(i=0;i<10;++i)
        insert(&myQueue,arr[i]);
    for(i=0;i<10;++i)
        printf("%d ",myQueue.data[i]);
    printf("\n");
    printf("%d \n",extract_max(&myQueue));
    for(i=0;i<myQueue.size;++i)
        printf("%d ",myQueue.data[i]);
    free(myQueue.data);
}