堆排序_HeapSort

叶孤程

已于 2024-01-22 01:18:41 修改

阅读量386

点赞数 8

文章标签：算法

于 2024-01-22 01:17:09 首次发布

本文链接：https://blog.csdn.net/restore_1/article/details/135738449

版权

本文详细介绍了堆排序算法，包括其工作原理、两种堆类型（大顶堆和小顶堆）、实现逻辑、代码示例以及堆排序的优缺点，如平均时间复杂度为O(nlogn)，效率高但不稳定且不适用于小规模数据。

摘要由CSDN通过智能技术生成

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：

大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；

堆排序的平均时间复杂度为 Ο(nlogn)。

1.实现逻辑

构建初始堆：将待排序序列视为一个完全二叉树，从最后一个非叶子节点开始，从后往前逐个进行堆调整操作。堆调整操作是指将当前节点与其左右孩子节点进行比较，如果存在比当前节点更大（或更小）的孩子节点，就交换它们的位置，然后继续对交换后的孩子节点进行堆调整，直到当前节点满足大顶堆（或小顶堆）的性质。这样就构建了一个初始堆。
排序：将堆顶元素与堆尾元素交换位置，即将当前最大（或最小）元素放到了序列的末尾。然后对剩余的除了最后一个元素的序列进行堆调整，将其重新调整为一个有序堆。重复这个过程，直到所有元素都排好序。

2.算法步骤

创建一个堆 H[0……n-1]；
把堆首（最大值）和堆尾互换；
把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；
重复步骤 2，直到堆的尺寸为 1;

3.动图演示

4.代码示例

4.1-C语言

#include <stdio.h>

// 堆排序函数
void heapSort(int arr[], int n) {
    // 构建最大堆
    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);
    }
}
 
// 将指定位置的元素下沉，构建最大堆
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);
    }
}

// 测试堆排序函数
int main() {
    int arr[] = {9, 7, 5, 11, 12, 2, 14, 10};
    int n = sizeof(arr) / sizeof(arr[0]);
 
    heapSort(arr, n);
 
    printf("排序后的数组：");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");
 
    return 0;
}

4-2.C++

#include <iostream>
using namespace std;

// 对以root为根的子树进行堆调整
void heapify(int arr[], int n, int root)
{
    int largest = root; // 将根节点设为最大值
    int left = 2 * root + 1; // 左孩子节点
    int right = 2 * root + 2; // 右孩子节点

    // 如果左孩子比根节点大，更新最大值
    if (left < n && arr[left] > arr[largest])
        largest = left;

    // 如果右孩子比最大值大，更新最大值
    if (right < n && arr[right] > arr[largest])
        largest = right;

    // 如果最大值不是根节点，交换并继续调整子树
    if (largest != root)
    {
        swap(arr[root], arr[largest]);
        heapify(arr, n, largest);
    }
}

void heapSort(int arr[], int n)
{
    // 构建最大堆（从最后一个非叶子节点开始进行堆调整）
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    // 依次将堆顶元素（最大值）与最后一个元素交换，并重新调整堆
    for (int i = n - 1; i >= 0; i--)
    {
        swap(arr[0], arr[i]);
        heapify(arr, i, 0);
    }
}

int main()
{
    int arr[] = {12, 11, 13, 5, 6, 7};
    int n = sizeof(arr) / sizeof(arr[0]);

    heapSort(arr, n);

    cout << "Sorted array: \n";
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";

    return 0;
}

4.3-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; // 初始化最大值为当前节点
        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 = {4, 10, 3, 5, 1};
        heapSort(arr);

        System.out.println("排序结果:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

5.堆排序优点

效率高：堆排序的平均时间复杂度为O(nlogn)，在实际应用中，堆排序的效率往往比其他排序算法高，尤其是对于大量数据的排序。
不需要额外的存储空间：堆排序可以在原始数组上进行操作，不需要额外的存储空间，因此节省了内存空间的使用。
稳定性：堆排序是一种稳定的排序算法，即相等元素的相对顺序在排序后不会改变。

6.堆排序缺点

不稳定：在建堆的过程中，由于比较和交换的操作在不同分支上进行，所以可能会改变相等元素的相对顺序。
不适用于小规模数据：堆排序适用于大规模数据的排序，但对于小规模数据来说，堆排序的效率相对较低。
需要额外的空间：虽然在排序过程中不需要额外的存储空间，但是在建堆的过程中需要额外的存储空间来存储堆，这会占用一定的内存空间。

总结起来，堆排序的优点是效率高、不需要额外的存储空间，并且是稳定的排序算法。缺点是不稳定、不适用于小规模数据，并且需要额外的存储空间。