堆排序（Heap）：从原理到实现的深度解析

在算法里，堆排序（Heap Sort）以其稳定的 $O(n\log n)$ 时间复杂度和 $O(1)$ 的空间复杂度，占据着重要的一席之地。它不像快速排序那样在最坏情况下会退化，也不像归并排序那样需要额外的内存空间。

一、什么是“堆”(Heap)

在开始排序之前，我们必须先搞清楚什么是“堆”。这里的堆不是内存管理中的“堆区”，而是一种特殊的完全二叉树数据结构。

在堆排序中，我们通常使用大顶堆来实现升序排序。大顶堆的定义很简单：

• 完全二叉树：除了最后一层，其他层的节点数都是满的，且最后一层的节点从左到右依次排列。
• 堆特性：每个父节点的值都大于或等于其左右子节点的值。

这意味着，在大顶堆中，根节点（堆顶）永远是整个堆中最大的元素。

数组与二叉树的映射
虽然我们把它看作树，但在 C++ 中，我们通常直接用数组（或 std::vector）来存储它，不需要构建复杂的节点类。假设数组下标从 0 开始，对于任意下标 $i$ 的节点：

• 父节点下标：$(i-1)/2$
• 左子节点下标：$2\times i+1$
• 右子节点下标：$2\times i+2$

二、堆排序核心逻辑

堆排序的过程可以概括为两个主要阶段：

1. 建堆：将一个无序数组构建成一个大顶堆。
2. 排序：反复将堆顶元素（最大值）与数组末尾元素交换，然后缩小堆的范围并重新调整，直到整个数组有序。

1：构建大顶堆

建堆的关键在于“下沉调整”。我们需要从最后一个非叶子节点开始，自底向上，自右向左地调整每一个子树，使其满足大顶堆的性质。

为什么从最后一个非叶子节点开始？
因为叶子节点没有子节点，天然满足堆的性质。最后一个非叶子节点的下标可以通过公式计算得出：$n/2-1$（其中 $n$ 是数组长度）。

下沉调整函数
这是堆排序的灵魂。它的作用是：假设当前节点的左右子树已经是堆，但当前节点可能破坏了堆的性质（比如它的值比子节点小），我们需要把它“下沉”到合适的位置。

#include <iostream>
#include <vector>
#include <algorithm> // for std::swap

using namespace std;

// 下沉调整函数
// arr: 待调整数组
// i: 当前需要下沉的节点索引
// heapSize: 当前堆的有效大小
void siftDown(vector<int>& arr, int i, int heapSize) {
    int largest = i; // 假设当前节点是最大的
    int left = 2 * i + 1;   // 左孩子
    int right = 2 * i + 2;  // 右孩子

    // 1. 找出父节点、左孩子、右孩子三者中的最大值
    if (left < heapSize && arr[left] > arr[largest]) {
        largest = left;
    }
    if (right < heapSize && arr[right] > arr[largest]) {
        largest = right;
    }

    // 2. 如果最大值不是当前节点，说明需要交换并继续下沉
    if (largest != i) {
        swap(arr[i], arr[largest]);
        // 递归调整被交换下去的子树
        siftDown(arr, largest, heapSize);
    }
}

建堆过程

void buildHeap(vector<int>& arr) {
    int n = arr.size();
    // 从最后一个非叶子节点开始，向前遍历
    for (int i = n / 2 - 1; i >= 0; --i) {
        siftDown(arr, i, n);
    }
}

2：排序与调整

建好大顶堆后，数组的第一个元素 arr[0] 就是最大值。但这还不够，我们需要把它放到最终的位置。

1. 交换：将堆顶元素 arr[0] 与数组末尾元素 arr[n-1] 交换。此时，最大值已经归位。
2. 缩小堆：将堆的大小减 1（忽略刚才排好序的末尾元素）。
3. 调整：此时堆顶元素可能破坏了堆的性质，我们需要对新的堆顶调用 siftDown，将其重新调整为大顶堆。
4. 重复：重复上述步骤，直到堆的大小为 1。

三、完整的 C++ 代码实现

将上述逻辑组合起来，就是一个完整的堆排序算法。

void heapSort(vector<int>& arr) {
    int n = arr.size();

    // 1. 建堆：O(n)
    // 从最后一个非叶子节点开始下沉
    for (int i = n / 2 - 1; i >= 0; --i) {
        siftDown(arr, i, n);
    }

    // 2. 排序：O(n log n)
    // 每次将堆顶（最大值）移到末尾，并缩小堆范围
    for (int i = n - 1; i > 0; --i) {
        swap(arr[0], arr[i]);       // 交换堆顶和当前末尾
        siftDown(arr, 0, i);        // 对新的堆顶进行下沉调整，堆大小变为 i
    }
}

int main() {
    vector<int> arr = {4, 6, 8, 5, 9, 1, 2};
    
    cout << "排序前: ";
    for (int x : arr) cout << x << " ";
    cout << endl;

    heapSort(arr);

    cout << "排序后: ";
    for (int x : arr) cout << x << " ";
    cout << endl;

    return 0;
}

四、复杂度分析

总结

堆排序是一种非常“稳健”的算法。它没有快速排序的最坏情况退化问题，也没有归并排序的空间开销。虽然在实际工程中，由于常数因子较大且缓存局部性不如快速排序，它可能不是最快的，但在对内存有严格限制或要求最坏时间复杂度可控的场景下，堆排序依然是最佳选择之一。