我们来详细、系统地解释一下**堆排序**。
堆排序是一种基于**二叉堆**数据结构的比较类排序算法。它以其原址排序（只需要常数级别的额外空间）和O(n log n)的时间复杂度而闻名。
为了理解堆排序，我们需要分步拆解几个核心概念。
- 什么是"堆"？
这里的"堆"不是指内存管理中的堆，而**是一种特殊的**完全二叉树**。**它必须满足以下性质之一：
* **大顶堆 **：每个节点的值都**大于或等于**其左右子节点的值。
* 推论：堆顶（根节点）是整个堆中的**最大元素**。
* **小顶堆 **：每个节点的值都**小于或等于**其左右子节点的值。
* 推论：堆顶（根节点）是整个堆中的**最小元素**。
在堆排序中，我们通常使用**大顶堆**。
**重要特性**：堆通常用**数组**来存储。对于一个给定下标 `i` 的节点：
* 其父节点下标：`(i-1) / 2`
* 其左子节点下标：`2*i + 1`
* 其右子节点下标：`2*i + 2`
例如，下面是一个大顶堆及其数组表示：
```
90
/ \
80\] \[70
/ \ /
40\] \[30\]\[20
```
数组：`[90, 80, 70, 40, 30, 20]`
- 堆排序的核心思想
堆排序的巧妙之处在于利用了大顶堆（或小顶堆）的堆顶是最大（或最小）值这一特性。其基本思想可以概括为两个步骤：
-
**建堆**：将一个无序的数组构建成一个大顶堆。
-
**排序**：不断地将堆顶元素（当前最大值）与堆的末尾元素交换，然后缩小堆的范围，并对新的堆顶元素进行"下沉"操作，以重新维持堆的性质。重复此过程，直到堆中只剩下一个元素。
3. 堆排序的详细步骤
我们以数组 `[4, 10, 3, 5, 1]` 的升序排序为例（使用大顶堆）。
步骤一：构建大顶堆
目标是重新排列数组元素，使其满足大顶堆的性质。
-
**从最后一个非叶子节点开始**。最后一个非叶子节点的下标是 `n/2 - 1` （n是数组长度）。这里 `n=5`，所以从下标 `5/2 - 1 = 1` 开始（即元素 `10`）。
-
**进行"下沉"操作**：
* **"下沉"**：对于一个节点，如果它比它的子节点小，就将它与较大的那个子节点交换，并继续向下比较，直到它大于等于它的所有子节点，或者成为叶子节点。
- **从下到上，从右到左地对所有非叶子节点执行"下沉"** ：
* 处理下标1（元素10）：它的子节点是下标3(5)和4(1)。10比它们都大，无需下沉。堆状态：`[4, 10, 3, 5, 1]`
* 处理下标0（元素4）：它的子节点是下标1(10)和2(3)。4 < 10，所以与10交换。交换后，下标1变成了4。现在4的子节点是下标3(5)和4(1)。4 < 5，所以与5交换。交换后，下标3变成了4，它已经是叶子节点，停止。
* 现在数组变成了：`[10, 5, 3, 4, 1]`。检查一下，这已经是一个大顶堆了。
```
10
/ \
5\] \[3
/ \
4\] \[1
```
步骤二：排序
现在，堆顶元素（下标0）是最大值。
- **第一次交换与下沉**：
* 将堆顶元素(10)与当前堆的最后一个元素(1)交换。交换后，数组为 `[1, 5, 3, 4, 10]`。此时，`10` 已经位于其最终的正确位置。我们将堆的大小减1（现在有效的堆范围是前4个元素 `[1, 5, 3, 4]`）。
* 对新的堆顶元素 `1` 进行**下沉**操作，以重新构建大顶堆。
* 1的子节点是5和3。5更大，所以1和5交换。数组变为 `[5, 1, 3, 4, 10]`。
* 现在1（在下标1）的子节点是4（在下标3）。1 < 4，所以交换。数组变为 `[5, 4, 3, 1, 10]`。现在又形成了一个有效的大顶堆（范围在前4个元素）。
- **重复此过程**：
* **第二次**：将堆顶(5)与当前堆的最后一个元素(1)交换。数组变为 `[1, 4, 3, 5, 10]`。`5` 和 `10` 都在最终位置。堆大小减1（有效堆是 `[1, 4, 3]`）。
* 对 `1` 进行下沉：1的子节点是4和3，与4交换。数组变为 `[4, 1, 3, 5, 10]`。
* **第三次**：将堆顶(4)与当前堆的最后一个元素(3)交换。数组变为 `[3, 1, 4, 5, 10]`。`4`, `5`, `10` 在最终位置。堆大小减1（有效堆是 `[3, 1]`）。
* 对 `3` 进行下沉：3的子节点是1，无需交换。
* **第四次**：将堆顶(3)与当前堆的最后一个元素(1)交换（也就是自己和自己交换）。数组变为 `[1, 3, 4, 5, 10]`。排序完成。
最终，我们得到了升序排列的数组：`[1, 3, 4, 5, 10]`。
- 算法复杂度分析
* **时间复杂度**：**O(n log n)**
* **建堆过程**：看似是O(n log n)，但通过精细分析，其平均时间复杂度可以达到**O(n)**。
* **排序过程**：需要进行n-1次循环，每次循环中主要操作是堆顶的"下沉"，下沉操作的时间复杂度与树高有关，即O(log n)。所以排序过程的时间复杂度是**O(n log n)**。
* 综合起来，堆排序的**最好、最坏、平均**时间复杂度都是 **O(n log n)**。这是一个非常稳定的性能。
* **空间复杂度**：**O(1)**
* 因为堆排序是**原址排序**，所有操作都在原数组上进行，只使用了常数级别的临时变量。
- 优缺点
**优点**：
* 时间复杂度稳定在O(n log n)，效率高。
* 空间复杂度低，是原址排序。
**缺点**：
* 算法不稳定（相等的元素在排序后相对位置可能会改变）。
* 在数据量较小的情况下，其常数因子可能使得性能不如快速排序或归并排序。
* 由于内存访问模式比较跳跃（不像快速排序那样局部顺序访问），对CPU缓存不友好。
总结
堆排序是一种高效且节省内存的排序算法。它的核心在于：
-
**将待排序序列构造成一个大顶堆**。
-
**不断取出堆顶的最大值，并将其放到序列末尾，然后调整剩余部分使其保持堆结构**。
理解堆排序的关键在于理解**堆的数据结构**和**下沉操作**。
例子构建数字序列 **825479** 的大顶堆。
1. 将数组视为完全二叉树
首先，我们将数组 `[8, 2, 5, 4, 7, 9]` 看作一个完全二叉树：
```
8
/ \
2 5
/ \ /
4 7 9
```
数组索引对应关系：
-
索引0: 8
-
索引1: 2
-
索引2: 5
-
索引3: 4
-
索引4: 7
-
索引5: 9
2. 构建大顶堆的过程
**大顶堆性质**：每个节点的值都大于或等于其子节点的值。
我们从最后一个非叶子节点开始向前调整（最后一个非叶子节点下标 = n/2 - 1 = 6/2 - 1 = 2）。
步骤1：调整索引2（值为5）
节点5的子节点是9（索引5），5 < 9，需要交换：
```
交换前：
5
/
9
交换后：
9
/
5
```
数组变为：`[8, 2, 9, 4, 7, 5]`
树结构：
```
8
/ \
2 9
/ \ /
4 7 5
```
步骤2：调整索引1（值为2）
节点2的子节点是4和7，最大值是7，2 < 7，需要交换：
```
交换前：
2
/ \
4 7
交换后：
7
/ \
4 2
```
数组变为：`[8, 7, 9, 4, 2, 5]`
树结构：
```
8
/ \
7 9
/ \ /
4 2 5
```
步骤3：调整索引0（值为8）
节点8的子节点是7和9，最大值是9，8 < 9，需要交换：
```
交换前：
8
/ \
7 9
交换后：
9
/ \
7 8
```
数组变为：`[9, 7, 8, 4, 2, 5]`
树结构：
```
9
/ \
7 8
/ \ /
4 2 5
```
步骤4：检查交换后的影响
交换后，索引2的值变为8，需要检查是否需要继续调整：
节点8的子节点是5，8 > 5，不需要调整。
3. 最终的大顶堆
**最终数组**：`[9, 7, 8, 4, 2, 5]`
**树形结构**：
```
9
/ \
7 8
/ \ /
4 2 5
```
**验证大顶堆性质**：
-
节点9 ≥ 子节点7和8 ✓
-
节点7 ≥ 子节点4和2 ✓
-
节点8 ≥ 子节点5 ✓
-
叶子节点4、2、5没有子节点 ✓
原始数组 `[8, 2, 5, 4, 7, 9]` 经过堆化后，得到的大顶堆为 `[9, 7, 8, 4, 2, 5]`。
这个堆满足大顶堆的所有条件，堆顶元素9是整个堆中的最大值。如果要进行堆排序，接下来就可以开始不断取出堆顶元素进行排序了。