目录
堆排序（Heap Sort）是一种基于堆数据结构的排序算法。堆是一种特殊的完全二叉树，堆排序利用堆的性质通过一系列操作将数组元素按升序或降序排列。堆排序的时间复杂度为 O(n log n)，是一种不稳定的排序算法，且其空间复杂度为 O(1)，因此在某些场景下非常有用。
一、堆排序的基本原理
堆排序的核心是堆（Heap）这一数据结构，堆有两种形式：
（1）最大堆（Max-Heap）： 每个节点的值大于或等于其子节点的值，根节点的值是整个堆的最大值。
**（2）最小堆（Min-Heap）：**每个节点的值小于或等于其子节点的值，根节点的值是整个堆的最小值。
堆排序一般使用最大堆来排序数组。堆排序的过程可以分为两个主要步骤：
（1）构建最大堆： 将无序数组转换成最大堆。
**（2）排序过程：**反复将堆顶元素（最大值）与当前堆的最后一个元素交换，然后调整堆，直到堆中只剩下一个元素。
二、堆排序的实现步骤
（1）构建最大堆： 首先将输入的无序数组构造成最大堆。此时数组中的最大元素位于根节点。
（2）交换堆顶元素与最后一个元素： 将堆顶元素与堆的最后一个元素交换，并减小堆的有效元素数量。
（3）堆化： 将根节点与其子节点进行比较，调整堆的结构，使其重新满足最大堆的性质。
**（4）重复步骤2和3：**直到堆的有效元素数量为1，整个数组已经排序完成。
三、堆排序的时间复杂度和空间复杂度
（1）时间复杂度： 构建最大堆的时间复杂度是 O(n)，而每次堆化的时间复杂度是 O(log n)，因此总的时间复杂度为 O(n log n)。
（2）空间复杂度： 堆排序是原地排序算法，因此其空间复杂度为 O(1)。四、堆排序的Java实现
下面是堆排序的Java实现代码：
java
public class HeapSort {
// 堆化过程，保证以i为根的子树满足堆的性质
private static void heapify(int[] arr, int n, int i) {
int largest = i; // 初始化最大值为根节点
int left = 2 * i + 1; // 左子节点的位置
int right = 2 * i + 2; // 右子节点的位置
// 如果左子节点大于根节点
if (left < n && arr[left] > arr[largest]) {
largest = left;
}
// 如果右子节点大于当前最大值
if (right < n && arr[right] > arr[largest]) {
largest = right;
}
// 如果最大值不是根节点，交换并继续堆化
if (largest != i) {
int temp = arr[i];
arr[i] = arr[largest];
arr[largest] = temp;
// 递归堆化受影响的子树
heapify(arr, n, largest);
}
}
// 堆排序主函数
public static void heapSort(int[] arr) {
int n = arr.length;
// 构建最大堆
for (int i = n / 2 - 1; i >= 0; i--) {
heapify(arr, n, i);
}
// 逐步将堆顶元素与最后一个元素交换，并调整堆
for (int i = n - 1; i >= 1; i--) {
// 将堆顶元素与当前未排序部分的最后一个元素交换
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
// 调整堆
heapify(arr, i, 0);
}
}
// 打印数组
private static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
public static void main(String[] args) {
int[] arr = {4, 10, 3, 5, 1};
System.out.println("Original array:");
printArray(arr);
heapSort(arr);
System.out.println("Sorted array:");
printArray(arr);
}
}四、堆排序的工作流程
让我们通过一个简单的例子来理解堆排序的工作流程。
1. 构建最大堆
假设我们有一个数组 arr = [4, 10, 3, 5, 1]。
（1）初始数组：[4, 10, 3, 5, 1]
（2）构建最大堆的过程中，我们从 i = n/2 - 1 开始，依次调整每个节点，直到根节点。
（3）调整后的堆：[10, 5, 3, 4, 1]，此时堆顶的元素是最大值。
2. 排序过程
交换堆顶元素与最后一个元素，并调整堆。
（1）第一次交换： 交换堆顶和最后一个元素后，数组变为：[1, 5, 3, 4, 10]。然后对剩余元素进行堆化，调整后的堆是：[5, 4, 3, 1, 10]。
（2）第二次交换： 交换堆顶和倒数第二个元素，数组变为：[1, 4, 3, 5, 10]，调整后的堆是：[4, 1, 3, 5, 10]。
（3）第三次交换： 交换堆顶和倒数第三个元素，数组变为：[3, 1, 4, 5, 10]，调整后的堆是：[3, 1, 4, 5, 10]。
**（4）第四次交换：**交换堆顶和倒数第四个元素，数组变为：[1, 3, 4, 5, 10]，此时只有一个元素剩下，排序完成。
最终，数组变为升序排列：[1, 3, 4, 5, 10]。
五、堆排序的优缺点
优点：
（1）时间复杂度稳定： 无论输入数据如何，堆排序的时间复杂度始终为 O(n log n)，不受数据分布影响。
（2）空间复杂度低： 堆排序是原地排序算法，其空间复杂度为 O(1)，无需额外的辅助空间。
**（3）适合大数据处理：**由于堆排序的时间复杂度稳定且不依赖于数据的初始状态，它适用于大数据量的排序。
缺点：
（1）不是稳定排序： 堆排序不保证相等元素的相对顺序，因此不适用于需要稳定排序的场景。
**（2）常数因素较大：**虽然堆排序的时间复杂度是 O(n log n)，但其常数因素较大，通常比快速排序和归并排序要慢，尤其在处理小数据集时。
六、堆排序的应用场景
（1）优先队列实现： 堆可以用来实现优先队列，特别是在需要频繁获取最大或最小值的场景中（例如，Dijkstra算法、Huffman编码）。
**（2）外部排序：**当数据量过大，不能全部加载到内存时，堆排序可以有效地对外部存储的海量数据进行排序。
总结
堆排序是一种基于堆数据结构的排序算法，具有 O(n log n) 的时间复杂度和 O(1) 的空间复杂度。尽管堆排序是一个不稳定的排序算法，但其高效性和原地排序特性使它在某些特定场景中非常有用，尤其是在需要频繁访问最大值或最小值的应用中。