堆排序

堆排序利用了大根堆（或小根堆）堆顶记录的 关键字最大（或最小）这一特征，使得在当前无序区中选取最大（或最小）关键字的记录变得简单。

（1）用大根堆排序的基本思想

① 先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区

② 再将关键字最大的记录R[1]（即堆顶）和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key

③由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。

……

直到无序区只有一个元素为止。

（2）大根堆排序算法的基本操作：

① 初始化操作：将R[1..n]构造为初始堆；

② 每一趟排序的基本操作：将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换，然后将新的无序区调整为堆（亦称重建堆）。
其实堆排序跟选择排序没什么区别，都是依次遍历下次寻找最大或者最小的值，保存后为一个有序顺序，然后从无序中在进行排序，直到最后剩下一个！
    #include <stdio.h>
    #include <stdlib.h>
    
    void HeapSort(int num[],int size);
    void BuildHeap(int num[] ,int size);
    void PercolateDown(int num[] , int index,int size);
    void PrintHeap(const char* strMsg,int array[],int nLength);
    void Swap(int num[] , int v, int u);
    
    int main(int argc, char *argv[])
    {
      /* 将数组看成完全二叉树的中序遍历结果的线性存储 */
      int data[13]={8,5,4,6,13,7,2,9,12,11,3,10,1};
      HeapSort(data,13);
       

      return 0;
    }
    
    
    void HeapSort(int num[] ,int size)
    {
        int i;
        int iLength=size;
         
        PrintHeap("Befor Sort:",num,iLength);
         
        BuildHeap(num,size);// 建立小顶堆  
         
        for (i = iLength - 1; i >= 1; i--) {  
            Swap(num, 0, i);// 交换  
            size--;// 每交换一次让规模减少一次  
            PercolateDown(num, 0,size);// 将新的首元素下滤操作
            PrintHeap("Sort Heap:",num,iLength);
        }
    }
    
    /* 建堆方法，只需线性时间建好；
       建堆的结果：数组的第一个元素（即树根）是所有元素中的最小值，索引小于等于size/2-1的其它元素（即其它非叶子节点）的值都是其所在子树的最小值 */  
    void BuildHeap(int num[] ,int size) {
        int i;
        //从最后一个非叶子节点开始，对每个非叶子节点进型最小根调整，保证每个根节点都是其子树中的最小值
        for (i = size / 2 - 1; i >= 0; i--) {  
            PercolateDown(num, i,size);// 进行下滤操作
            PrintHeap("Build heap:",num,size);
        }  
    }
         
    /* 对该数进行下滤操作，直到该数比左右节点都小就停止下滤。
       即对某个根节点的值进行位置下降调整，使该值比其左右子节点都小；
       若该节点是叶子节点，则无法while循环 */
    void PercolateDown(int num[] , int index,int size) {  
        int min;// 设置最小指向下标  
        while (index * 2 + 1<size) {// 如果该数有左节点，则假设左节点最小  
            min = index * 2 + 1;// 获取左节点的下标  
            if (index * 2 + 2<size) {// 如果该数还有右节点  
                if (num[min] > num[index * 2 + 2]) {// 就和左节点分出最小者  
                    min = index * 2 + 2;// 此时右节点更小，则更新min的指向下标  
                }  
            }  
            // 此时进行该数和最小者进行比较，  
            if (num[index] < num[min]) {// 如果index最小，  
                break;// 停止下滤操作  
            } else {  
                Swap(num, index, min);// 交换两个数，让大数往下沉  
                index = min;// 更新index的指向  
            }  
        }// while  
    }
         
    // 给定数组交换两个数的位置  
    void Swap(int num[] , int v, int u) {
        int temp = num[v];  
        num[v] = num[u];  
        num[u] = temp;  
    }  
    
    void PrintHeap(const char* strMsg,int array[],int nLength)
    {
         int i;
         printf("%s",strMsg);
         for(i=0;i<nLength;i++)
         {
            printf("%d ",array[i]);
         }
         printf("\n");
    }