admin管理员组

文章数量:1032493

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

堆排序（Heap Sort）起源

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

定义

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

引伸义

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

优缺点

优点：

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

缺点：

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

使用场景

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

使用数据一步步举例

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

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

Java示例代码

代码语言：javascript代码运行次数：0运行复制
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] + " ");  
        }  
    }  
}

　　运行上面的代码，你将得到排序后的数组输出：

代码语言：javascript代码运行次数：0运行复制
Sorted array is  
5 6 7 11 12 13
本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。 原始发表：2024-05-27，如有侵权请联系 cloudcommunity@tencent 删除数组heapsort排序排序算法

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

堆排序（Heap Sort）起源

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

定义

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

引伸义

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

优缺点

优点：

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

缺点：

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

使用场景

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

使用数据一步步举例

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

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

Java示例代码

代码语言：javascript代码运行次数：0运行复制
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] + " ");  
        }  
    }  
}

　　运行上面的代码，你将得到排序后的数组输出：

代码语言：javascript代码运行次数：0运行复制
Sorted array is  
5 6 7 11 12 13
本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。 原始发表：2024-05-27，如有侵权请联系 cloudcommunity@tencent 删除数组heapsort排序排序算法

本文标签： 常用的排序算法之堆排序（Heap Sort）

版权声明：本文标题：常用的排序算法之堆排序（Heap Sort） 内容由热心网友自发贡献，该文观点仅代表作者本人， 转载请联系作者并注明出处：http://it.en369.cn/jiaocheng/1747941195a2231050.html， 本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。