1. 堆排序原理图解
堆排序是一种基于二叉堆（通常使用最大堆）的排序算法。其核心思想是利用堆的性质（父节点的值大于或等于子节点的值）来高效地进行排序。堆排序分为两个主要阶段：建堆和排序。
堆排序步骤：
1. 建堆：
- 将无序数组构建成一个最大堆。
- 从最后一个非叶子节点开始，逐个调整节点，使其满足堆的性质。
2. 排序：
- 将堆顶元素（最大值）与堆的最后一个元素交换。
- 缩小堆的范围，重新调整堆，使其满足最大堆的性质。
- 重复上述过程，直到堆的大小为1。
图解示例：
假设数组为 `[4, 10, 3, 5, 1]`。
1. 初始状态：`[4, 10, 3, 5, 1]`
2. 建堆：
- 调整节点，构建最大堆：`[10, 5, 3, 4, 1]`
3. 排序过程：
- 将堆顶元素（10）与最后一个元素（1）交换：`[1, 5, 3, 4, 10]`
- 调整剩余的堆（`[1, 5, 3, 4]`），使其满足最大堆的性质：`[5, 4, 3, 1]`
- 将堆顶元素（5）与最后一个元素（1）交换：`[1, 4, 3, 5, 10]`
- 调整剩余的堆（`[1, 4, 3]`），使其满足最大堆的性质：`[4, 1, 3]`
- 将堆顶元素（4）与最后一个元素（3）交换：`[3, 1, 4, 5, 10]`
- 调整剩余的堆（`[3, 1]`），使其满足最大堆的性质：`[3, 1]`
- 将堆顶元素（3）与最后一个元素（1）交换：`[1, 3, 4, 5, 10]`
4. **最终结果**：`[1, 3, 4, 5, 10]`
2. Java代码实现及注释
```java
import java.util.Arrays;
public class HeapSort {
public static void main(String[] args) {
int[] array = {4, 10, 3, 5, 1};
heapSort(array);
System.out.println("排序后的数组：");
System.out.println(Arrays.toString(array));
}
// 堆排序主方法
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 >= 0; i--) {
// 交换堆顶元素与最后一个元素
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
// 调整剩余的堆
heapify(arr, i, 0);
}
}
// 调整堆的方法
private static void heapify(int[] arr, int heapSize, int rootIndex) {
int largest = rootIndex; // 假设根节点是最大的
int leftChild = 2 * rootIndex + 1; // 左子节点
int rightChild = 2 * rootIndex + 2; // 右子节点
// 如果左子节点大于根节点
if (leftChild < heapSize && arr[leftChild] > arr[largest]) {
largest = leftChild;
}
// 如果右子节点大于当前最大的节点
if (rightChild < heapSize && arr[rightChild] > arr[largest]) {
largest = rightChild;
}
// 如果最大的节点不是根节点，交换它们
if (largest != rootIndex) {
int temp = arr[rootIndex];
arr[rootIndex] = arr[largest];
arr[largest] = temp;
// 递归调整子树
heapify(arr, heapSize, largest);
}
}
}
```
3. 代码说明
1. 建堆：
- 从最后一个非叶子节点开始，逐个调整节点，使其满足最大堆的性质。
- 使用 `heapify` 方法调整节点。
2. 排序：
- 将堆顶元素（最大值）与堆的最后一个元素交换。
- 缩小堆的范围，重新调整堆，使其满足最大堆的性质。
- 重复上述过程，直到堆的大小为1。
3. 时间复杂度：
- **最坏情况**：`O(n log n)`。
- **平均情况**：`O(n log n)`。
- **最好情况**：`O(n log n)`。
4. 空间复杂度：
- `O(1)`，因为堆排序是原地排序算法，不需要额外的存储空间。
5. 稳定性：
- 堆排序是**不稳定的**，因为交换操作可能改变相同值元素的相对顺序。
4. 应用场景
1. 大规模数据排序：
- 堆排序的时间复杂度为 `O(n log n)`，适合对大规模数据进行排序。
2. 优先队列实现：
- 堆排序的核心思想可以用于实现优先队列，例如在任务调度中。
3. 教学和演示：
- 堆排序的实现清晰，适合用于教学和算法演示。
5. 总结
堆排序是一种高效的排序算法，基于二叉堆的性质实现。它的时间复杂度稳定在 `O(n log n)`，并且是原地排序算法，不需要额外的存储空间。然而，堆排序是不稳定的，因此在需要保持相同值元素相对顺序的场景中不适用。在实际应用中，堆排序常用于大规模数据排序和优先队列的实现。