随笔- 1102 文章- 35 评论- 228 阅读- 157万

常用的排序算法之堆排序（Heap Sort）

堆排序（Heap Sort）起源

堆排序的概念由J.W.J. Williams在1964年提出，并在计算机科学中得到了广泛的应用。它利用了堆这种数据结构所具备的性质来实现排序。堆通常是一个可以被看做一棵完全二叉树的数组对象。

定义

堆排序（Heap Sort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。

引伸义

堆排序算法可以看作是对直接选择排序的有效改进。在直接选择排序中，为了从R[1..n]中选出最小（或最大）的元素，我们必须扫描整个R[1..n]，而在堆排序中，只需将堆顶的元素与末尾的元素互换，然后重新调整堆结构，即可得到n个元素中的次小（或次大）元素。因此，堆排序的效率要高于直接选择排序。

优缺点

优点：

时间复杂度较低，平均时间复杂度为O(nlogn)。
空间复杂度为O(1)，因为它是原地排序算法，不需要额外的存储空间。

缺点：

不稳定排序算法，即相等的元素的相对顺序可能会改变。
对于数据量较小的场景，可能不如插入排序或选择排序快。

使用场景

堆排序适用于数据量较大且对空间复杂度要求不高的场景。由于其高效的时间复杂度，它经常被用于大数据排序等场景。

使用数据一步步举例

假设我们有一个数组 [4, 1, 3, 9, 7]，我们按照最大堆（父节点大于或等于子节点）的方式来进行堆排序。

建堆：首先将数组转换为最大堆。
- 初始数组：[4, 1, 3, 9, 7]
- 建堆后：[9, 7, 3, 4, 1]（注意：这里只展示了建堆后的结果，并没有展示建堆的具体步骤）
交换堆顶元素与末尾元素：将堆顶元素（最大值）与末尾元素交换。
- 交换后：[1, 7, 3, 4, 9]
重新调整堆：对剩余元素重新调整为大根堆。
- 重新调整后：[4, 7, 3, 1, 9]
重复步骤2和3：继续将堆顶元素与当前末尾元素交换，并重新调整堆，直到整个数组有序。
- 交换与调整后：[3, 7, 1, 4, 9]
- 再交换与调整后：[1, 3, 7, 4, 9]
- 最后得到有序数组：[1, 3, 4, 7, 9]

Java示例代码

public class HeapSort {  
       
    // 堆排序方法  
    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 n, int i) {  
        int largest = i; // 初始化largest为根  
        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 swap = arr[i];  
            arr[i] = arr[largest];  
            arr[largest] = swap;  
   
            // 递归调整受影响的子堆  
            heapify(arr, n, largest);  
        }  
    }  
   
    // 测试方法  
    public static void main(String args[]) {  
        int arr[] = {12, 11, 13, 5, 6, 7};  
        int n = arr.length;  
   
        heapSort(arr);  
   
        System.out.println("Sorted array is");  
        for (int i = 0; i < n; ++i) {  
            System.out.print(arr[i] + " ");  
        }  
    }  
}