堆排序

function HeapSort(arr){
        //1.构建大顶堆
        for(var i=arr.length/2-1;i>=0;i--){
            //从最后一个非叶子结点从下至上 
            adjustHeap(arr,i,arr.length);
        }
        //2.调整堆结构+交换堆顶元素与末尾元素
        for(var j=arr.length-1;j>0;j--){
            [arr[0],arr[j]]= [arr[j],arr[0]];//将堆顶元素与末尾元素进行值交换
            adjustHeap(arr,0,j);//重新对堆进行调整
        }
        console.log(arr);
    }
     //调整为大顶堆
    function adjustHeap(arr, i, length){
        var temp = arr[i];//先取出当前元素i
        for(var k=i*2+1;k<length;k=k*2+1){
            if(k+1<length && arr[k]<arr[k+1]){
                k++;
            }
            if(arr[k] >temp){
                arr[i] = arr[k];
                i = k;   
            }else{
                break;
            }
        }

        arr[i] = temp;//将temp值放到最终的位置
    } 

一、时间复杂度：

1、初始化建堆 假设深度为k，总的时间计算为： S =2^( i - 1 ) * ( k - i ) 因为叶子层不用交换，所以i从 k-1 开始到 1。   S = 2^(k-2) * 1 + 2^(k-3)2…..+2(k-2)+2^(0)*(k-1)   S = 2^k -k -1；由完全二叉树的深度为log(n) ，把此值带入；   得到：S = n - log(n) -1，所以初始化建堆时间复杂度为：O(n) 2、排序重建堆 重建堆一共需要n-1次循环，每次循环的比较次数为log(i)，则相加为：log2+log3+…+log(n-1)+log(n)≈log(n!)。可以证明log(n!)和nlog(n)是同阶函数，排序重建堆时间复杂度为：O(nlog(n)) 2、空间复杂度：O（1）

3、稳定性：不稳定