堆排序－HeapSort

堆排序与快速排序，归并排序一样都是时间复杂度为O(N*logN)。
二叉堆的定义
- 二叉堆是完全二叉树或者是近似完全二叉树。
- 二叉堆满足二个特性：
- 1．父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。
- 2．每个结点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。

当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆。

namespace HeapSort {
    class Solution {
    public:
        //在arr中0-length范围，以索引parent为根调整成最小堆
        //（前提parent左右子树都是最小堆）
        void adjustHeap(vector<int> &arr,int parent,int length){
            int tmp=arr[parent];    //先保存根parent的值
            int p=parent,c=2*p+1;   //设置p（parent）和c(child)
            while(c<length){
                //更新c为值小的c
                if(c+1<length && arr[c+1]<arr[c]){
                    c=c+1;
                }
                //如果tmp比c大，c值上移到p位置；同时更新p，c的值
                if(tmp>arr[c]){
                    arr[p]=arr[c];
                    p=c;
                    c=2*c+1;
                }else{  //否则，就是找到tmp的插入位置
                    break;
                }
            }
            //插入tmp到p位置
            arr[p]=tmp;
        }

        //
        void heapSort(vector<int> &arr){
            int length=arr.size();
            //从最后节点的父节点length/2开始到0，不断调整，达到建堆
            for(int i=length/2;i>=0;i--){
                adjustHeap(arr, i, length);
            }
            //每次把堆顶的值和尾部互换，然后尾部之前的新堆调整；如此循环
            for(int i=length-1;i>0;i--){
                swap(arr[0],arr[i]);
                adjustHeap(arr, 0, i);
            }
            //降序排列改到升序排列
            for(int i=0;i<length-i-1;i++){
                swap(arr[i],arr[length-i-1]);
            }
        }
    };

    class Test {
    public:
        static void main(){
            vector<int> vec{ 23, 65, 12, 3, 8, 76, 345, 90, 21, 75, 34, 61 };
            Solution s;
            s.heapSort(vec);
        }
    };
}