左神手撕|堆排序c++版

大根堆===》升序排列

class Heap_sort{
private:
 void swap(vector<int>&arr,int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
    void heapify(vector<int>&arr,int index,int heapSize){
        int left=index*2+1;//找到当前元素的左子节点
        while(left<heapSize){//确保它有子节点
        //找到它左右子节点中较大的一个（如果有右节点）
            int largest=left+1<heapSize&&arr[left+1]>arr[left]
                    ? left+1
                    : left;
            //比较当前元素与较大子节点的大小        
            largest=arr[largest]>arr[index]?largest:index;
            //如果当前元素仍大与它的子节点，则不用调整，当前结构就是一个大根堆
            if(largest==index)
                break;
            //否则让当前元素与它的较大子节点交换
            swap(arr,largest,index);
            index=largest;
            //然后再在交换完后位值，继续向下搜索
            left=index*2+1;
        }
    }
    void heapInsert(vector<int>&arr,int index){
    //新插入 元素与其父节点比较大小，如果比父节点大，就交换位值
        while(arr[index]>arr[(index-1)/2]){
            swap(arr,index,(index-1)/2);
            index=(index-1)/2;//继续向上搜索
        }
    }

public:  
    void heapSort(vector<int>&arr){
        if (arr.empty()||arr.size()<2){
            return;
        }
        //从头把整个数组调整成堆结构
        for(int i=0;i<arr.size();i++){
            heapInsert(arr,i);
        }
       // 此时堆的大小就是数组的大小
        int heapSize=arr.size();
       //交换堆顶元素和堆中的最后一个元素，
       //通过这种方式把堆顶元素扔到堆结构之外，堆的边界往前一位，这个被扔出来的元素就是最大值，之后就不会被调整
        swap(arr,0,--heapSize);
        while(heapSize>0){
        //然后把交换后堆内的元素调整成堆结构
            heapify(arr,0,heapSize);
            //堆边界继续往前收缩，丢出堆顶元素
            swap(arr,0,--heapSize);
        }
    }
};

heapify()：

一个大根堆的堆顶元素突然变小，heapify()可以让把整个数列重新调整成堆结构，每次调整的时间代价，只与层数有关，为O(logN)

heapInsert():

这个函数在已有的堆结构中再插入一个元素，保持堆结构不被破坏

heapsort()

这个函数先把顺序数列调整成大根堆结构，然后再通过堆将数组调整成升序排列的数组