大顶堆和小顶堆以及堆排

大顶堆

任何一非叶节点的关键字不小于其左右孩子节点的关键字，最顶端节点一定是序列中最大元素

小顶堆

任何一非叶节点的关键字不小于其左右孩子节点的关键字，最顶端节点一定是序列中最小元素

堆排序算法

时间复杂度：O(nlogn)
堆排序算法的时间复杂度分为两个主要部分：

• 建堆过程（Build Heap）：将原始数组建立成一个堆结构，这一过程的时间复杂度是 O(n)，其中 n 是数组中的元素数量。这是通过调用一系列的向下调整过程（也称为"heapify"）完成的，虽然每次调整的时间复杂度是 O(log n)，但整个建堆过程可以在 O(n) 时间内完成。
• 排序过程：进行 n-1 次的循环，每次循环删除堆顶元素并重新调整堆（也就是heapify）。每次调整的时间复杂度是 O(log n)，因此整个排序过程的时间复杂度是 O(n log n)。

空间复杂度： O(1)，采用的是原地排序方法

流程：
1）构造一个完全二叉树
2）将该树构建为大顶堆
3）将根节点与最后一个元素交换位置
4）将剩下的n-1个元素重新构建成大顶堆
5）重复（3）、（4）直到整个数组排序完成
前置知识：

• i节点的孩子节点为 2i +1和 2i+2 ；
• i节点的 父节点为：(i-1)/2；
• 最后一个非叶子节点：length/2 - 1

最终的代码：

function swap(A, i, j) {
    let temp = A[i];
    A[i] = A[j];
    A[j] = temp;
}
function shiftDown(A, i, length) {
    let temp = A[i]; //i指向根节点
    for(let j = 2*i+1; j<length; j = 2*j+1) { //从左孩子开始遍历
        temp = A[i];
        if(j+1 < length && A[j] < A[j+1]) { //比较左孩子和右孩子，将j指向较大的值
            j++;
        }
        if(temp < A[j]) { //如果根结点比孩子节点小，则交换，并将i指向该节点
            swap(A, i, j);
            i = j;
        } else {
            break; //反之，如果根节点比左右孩子都大，则结束遍历
        }
    }
}

// 堆排序
function heapSort(A) {
    //将树变为大顶堆，[4, 2, 8, 5, 3, 2] -> [8, 5, 4, 2, 3, 2]
    for(let i = Math.floor(A.length/2-1); i>=0; i--) {
        shiftDown(A, i, A.length);
    }
    for(let i = A.length-1; i>0; i--) {
        swap(A, 0, i); // 根节点与最后一个节点交换
        shiftDown(A, 0, i);
    }
}

let Arr = [4, 2, 8, 5, 3, 2];
heapSort(Arr);
console.log(Arr);   //[ 2, 2, 3, 4, 5, 8 ]

下面一张图反映了我此刻的心情~~~