堆排序和优先队列【最小堆】

最小堆性质： A[PARENT(i)]<=A[i]

   
   

    
    

     
     #include <iostream>
    
    
    
    

     
     
    
    
    
    

     
     using namespace std;
    
    
    
    

     
     #define N 13
    
    
    
    

     
     int HEAP_SIZE=N;
    
    
    
    

     
     
    
    
    
    

     
     void MIN_HEAP_INSERT(int a[],int key);
    
    
    
    

     
     int HEAP_DECREASE_KEY(int a[], int i, int key);
    
    
    
    

     
     int HEAP_EXTRACT_MIN(int a[]);
    
    
    
    

     
     int HEAP_MINMUM(int a[]);
    
    
    
    

     
     void HEAP_SORT(int a[], int n);
    
    
    
    

     
     
    
    
    
    

     
     void BUILD_MIN_HEAP(int a[], int n);
    
    
    
    

     
     void MIN_HEAPIFY(int a[], int i);
    
    
    
    

     
     void exchange(int a[], int i, int j);
    
    
    
    

     
     int LEFT(int a[], int i);
    
    
    
    

     
     int RIGHT(int a[], int i);
    
    
    
    

     
     int PARENT(int a[], int i);
    
    
    
    

     
     void PRINT(int a[], int n);
    
    
    
    

     
     
    
    
    
    

     
     int main()
    
    
    
    

     
     {
    
    
    
    

     
         int a[N+1]={-12,1,9,10,2,7,5,6,4,13,3,18,11,100};
    
    
    
    

     
     
    
    
    
    

     
         cout<<"数组初始化："<<endl;
    
    
    
    

     
         PRINT(a,N+1);
    
    
    
    

     
         cout<<"建立最小堆："<<endl;
    
    
    
    

     
         BUILD_MIN_HEAP(a,N+1);
    
    
    
    

     
         PRINT(a,N+1);
    
    
    
    

     
     
    
    
    
    

     
         cout<<"删除最小堆的当前最小元素："<<endl;
    
    
    
    

     
         HEAP_EXTRACT_MIN(a);
    
    
    
    

     
         PRINT(a,N);
    
    
    
    

     
         cout<<"最小堆第9位的数减小到2："<<endl;
    
    
    
    

     
         HEAP_DECREASE_KEY(a,9,2);
    
    
    
    

     
         PRINT(a,N);
    
    
    
    

     
         cout<<"最小堆插入一个元素56："<<endl;
    
    
    
    

     
         MIN_HEAP_INSERT(a,56);
    
    
    
    

     
         PRINT(a,N+1);
    
    
    
    

     
         cout<<"最小堆排序后的数组为："<<endl;
    
    
    
    

     
         HEAP_SORT(a,N+1);
    
    
    
    

     
         PRINT(a,N+1);
    
    
    
    

     
     
    
    
    
    

     
         return 0;
    
    
    
    

     
     }
    
    
    
    

     
     void MIN_HEAP_INSERT(int a[],int key){
    
    
    
    

     
         HEAP_SIZE++;
    
    
    
    

     
         a[HEAP_SIZE]=999;
    
    
    
    

     
         HEAP_DECREASE_KEY(a,HEAP_SIZE,key);
    
    
    
    

     
     }
    
    
    
    

     
     
    
    
    
    

     
     int HEAP_DECREASE_KEY(int a[], int i, int key){
    
    
    
    

     
         if(key>a[i])
    
    
    
    

     
             return -12;
    
    
    
    

     
         a[i]=key;
    
    
    
    

     
         while(i>1&&a[i]<a[PARENT(a,i)]){
    
    
    
    

     
             exchange(a,i,PARENT(a,i));
    
    
    
    

     
             i=PARENT(a,i);
    
    
    
    

     
         }
    
    
    
    

     
         return 0;
    
    
    
    

     
     }
    
    
    
    

     
     
    
    
    
    

     
     int HEAP_EXTRACT_MIN(int a[]){
    
    
    
    

     
         if(HEAP_SIZE<1){
    
    
    
    

     
             return -12;
    
    
    
    

     
         }
    
    
    
    

     
         int minn=a[1];
    
    
    
    

     
         a[1]=a[HEAP_SIZE];
    
    
    
    

     
         HEAP_SIZE--;
    
    
    
    

     
         MIN_HEAPIFY(a,1);
    
    
    
    

     
         return minn;
    
    
    
    

     
     
    
    
    
    

     
     }
    
    
    
    

     
     
    
    
    
    

     
     int HEAP_MINMUM(int a[]){
    
    
    
    

     
         return a[1];
    
    
    
    

     
     }
    
    
    
    

     
     
    
    
    
    

     
     void HEAP_SORT(int a[], int n){
    
    
    
    

     
         BUILD_MIN_HEAP(a,n);
    
    
    
    

     
         for(int i=HEAP_SIZE;i>=2;i--){
    
    
    
    

     
             exchange(a,1,i);
    
    
    
    

     
             HEAP_SIZE--;
    
    
    
    

     
             MIN_HEAPIFY(a,1);
    
    
    
    

     
         }
    
    
    
    

     
     }
    
    
    
    

     
     
    
    
    
    

     
     void BUILD_MIN_HEAP(int a[], int n){
    
    
    
    

     
         for(int i=(n-1)/2;i>=1;i--){
    
    
    
    

     
             MIN_HEAPIFY(a,i);
    
    
    
    

     
         }
    
    
    
    

     
     }
    
    
    
    

     
     
    
    
    
    

     
     void MIN_HEAPIFY(int a[], int i){
    
    
    
    

     
         //别忘了等于号
    
    
    
    

     
         while(i<=HEAP_SIZE/2){
    
    
    
    

     
             int l,r;
    
    
    
    

     
             l=LEFT(a,i);
    
    
    
    

     
             r=RIGHT(a,i);
    
    
    
    

     
             int small;
    
    
    
    

     
             if(l<=HEAP_SIZE&&a[l]<a[i])
    
    
    
    

     
                 small=l;
    
    
    
    

     
             else
    
    
    
    

     
                 small=i;
    
    
    
    

     
             if(r<=HEAP_SIZE&&a[r]<a[small])
    
    
    
    

     
                 small=r;
    
    
    
    

     
             if(i!=small){
    
    
    
    

     
                 exchange(a,i,small);
    
    
    
    

     
                 i=small;
    
    
    
    

     
             }else{
    
    
    
    

     
                 return;
    
    
    
    

     
             }
    
    
    
    

     
         }
    
    
    
    

     
     
    
    
    
    

     
     }
    
    
    
    

     
     void exchange(int a[], int i, int j){
    
    
    
    

     
         int temp=a[i];
    
    
    
    

     
         a[i]=a[j];
    
    
    
    

     
         a[j]=temp;
    
    
    
    

     
     }
    
    
    
    

     
     int LEFT(int a[], int i){
    
    
    
    

     
         return 2*i;
    
    
    
    

     
     }
    
    
    
    

     
     int RIGHT(int a[], int i){
    
    
    
    

     
         return 2*i+1;
    
    
    
    

     
     }
    
    
    
    

     
     int PARENT(int a[], int i){
    
    
    
    

     
         return i/2;
    
    
    
    

     
     }
    
    
    
    

     
     void PRINT(int a[], int n){
    
    
    
    

     
         for(int i=1;i<=n-1;i++)
    
    
    
    

     
             cout<<a[i]<<" ";
    
    
    
    

     
         cout<<endl;
    
    
    
    

     
     }
    
    
   
   

参考： http://blog.csdn.net/z84616995z/article/details/17797393#reply