C语言-堆（heap）排序算法的详解与实现

堆排序（Heap Sort）是一种高效的排序算法，基于堆这种数据结构实现。它具有稳定的O(nlogn)时间复杂度，适用于大规模数据的排序，尤其在实时数据处理和优先队列中应用广泛。本博客将深入介绍堆排序的原理、步骤以及使用C语言实现的示例。

堆的基本概念

堆是一种特殊的树形数据结构，它满足以下性质：

• 最大堆（Max Heap）：父节点的值大于或等于任何子节点的值。
• 最小堆（Min Heap）：父节点的值小于或等于任何子节点的值。

堆可以用数组实现，对于数组中的任意索引i：

• 父节点索引为 (i-1)/2
• 左子节点索引为 2*i + 1
• 右子节点索引为 2*i + 2

堆排序算法步骤

堆排序算法主要包括四个步骤：

1. 输入数组并建立大顶堆。完成后，最大元素位于堆顶。
2. 将堆顶元素（第一个元素）与堆底元素（最后一个元素）交换。完成交换后，堆的长度减 1 ，已排序元素数量加 1 。
3. 从堆顶元素开始，从顶到底执行堆化操作（sift down）。完成堆化后，堆的性质得到修复。
4. 循环执行第 2. 步和第 3. 步。循环 𝑛−1 轮后，即可完成数组排序。

堆排序示意图：

我们要将这棵树调整成大顶堆 ( 找到第一个非叶子结点，从后往前构建大顶堆) 。

然后，将堆顶元素和无序区的最后一个元素交换，将无序区的长度减 1 。将无序区重新调整为新的大顶堆。

C语言实现代码

下面是堆排序的C语言实现代码，每一行都有详细的注释解释其功能和实现细节：

#include <stdio.h>

// 交换数组中两个元素的位置
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 调整堆，使以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); // 调整堆，保持最大堆性质
    }
}

// 打印数组元素
void printArray(int arr[], int n) {
    for (int i = 0; i < n; ++i) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

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

    printf("Original array: ");
    printArray(arr, n);

    heapSort(arr, n);

    printf("Sorted array: ");
    printArray(arr, n);

    return 0;
}

算法特性

• 时间复杂度为 𝑂(𝑛log⁡𝑛)、非自适应排序：建堆操作使用 𝑂(𝑛) 时间。从堆中提取最大元素的时间复杂度为 𝑂(log⁡𝑛) ，共循环 𝑛−1 轮。
• 空间复杂度为 𝑂(1)、原地排序：几个指针变量使用 𝑂(1) 空间。元素交换和堆化操作都是在原数组上进行的。
• 非稳定排序：在交换堆顶元素和堆底元素时，相等元素的相对位置可能发生变化。