算法导论&堆排序&堆实现的优先队列

时间复杂度：O(nlgn)
空间复杂度：具有空间原址性,即O(n)

表示堆的数组包括两个属性：length是数组的长度,heap_size是堆的大小，某些操作要求某些数据不在堆中

把数组建成一个最大堆，就能利用堆实现最大优先队列了

#include<iostream>
using namespace std;
#define parent(i) (i/2)
#define left(i) (i*2)
#define right(i) (i*2+1)
#define len(a)  sizeof(a)/sizeof(a[0])
#define INF 0x3f3f3f
const int maxn = 100;
int heap_size;
int length;
int A[maxn];

//堆排序
void max_heapify(int A[],int i);//维护一个最大堆
void build_max_heap(int A[]);   //建立堆
void heapsort(int A[]); //排序

//优先队列
void heap_maximum(int A[]); //返回最大关键字元素
int heap_extract_max(int A[]);  //返回最大关键字元素并从对队列中删除
void heap_increase_key(int A[],int i,int key);  //把某节点值增加到key
void max_heap_insert(int A[],int key);  //把key值插入到队列中


int main(){
    int a[] = {110,4,34,55,66,32,22};
    length = len(a);
    heapsort(a);
    for(int i=0;i<length;i++){
        cout<<a[i]<<" ";
    }
}


void max_heapify(int A[],int i){
    int largest;
    int l = left(i);
    int r = right(i);
    if(l<=heap_size&&A[l]>A[i]){
        largest = l;
    }else{
        largest = i;
    }

    if(r<=heap_size&&A[r]>A[largest])
        largest = r;

    if(largest!=i){
        int t = A[i];
        A[i] = A[largest];
        A[largest] = t;
        max_heapify(A,largest);
    }

}

void build_max_heap(int A[]){
    heap_size = length;
    for(int i=length/2;i>=0;i--){
        max_heapify(A,i);
    }
}

void heapsort(int A[]){
    build_max_heap(A);
    for(int i=length;i>0;i--){
        int t = A[0];
        A[0] = A[i];
        A[i] = t;

        heap_size--;
        max_heapify(A,0);
    }
}



void heap_maximum(int A[]){
    return A[0];
}

int heap_extract_max(int A[]){
    if(heap_size<0) return -1;
    max = A[0];
    A[0] = A[heap_size];
    heap_size--;
    max_heapify(A,0);
    return max;
} 


int heap_increase_key(int A[],int i,int key){
    if(key<A[i])    return -1;
    A[i] = key;
    while(i>0&&A[parent(i)]<A[i]){
        int t = A[i];
        A[i] = A[parent(i)];
        A[parent(i)] = t;
        i = parent(i);
    }
}


void max_heap_insert(int A[],int key){
    heap_size++;
    A[heap_size] = -INF;
    heap_increase_key(heap_increase_key(A,heap_size,key));
}