堆排序的思路与改进（C 语言描述）

本文中的代码适用于对数组元素进行排序（以整型数据为例）。

关于堆排序的具体思路可以参考《算法》书中描述 堆排序 。

自定义的方法

在排序方法之前，定义了五个不同的方法，以便于对数组元素进行比较、交换和覆盖。为了适用于不同的数据类型，这里使用到了 void 指针以及指针类型的转换，也就是 C 语言中范型的概念。如果需要对不同元素类型的数组进行排序，只修改 LessArr() 方法即可。

// 比较数组中两个元素大小的方法
int LessArr(void *arr, int i, int j, int size)
{
    return *(int*) (arr + (i - 1) * size) < *(int*) (arr + (j - 1) * size);
}

// 交换数组中两个元素的方法
void Exch(void *arr, int i, int j, int size)
{
    void * temp = malloc(size);
    memcpy(temp, arr + (i - 1) * size, size);
    memcpy(arr + (i - 1) * size, arr + (j - 1) * size, size);
    memcpy(arr + (j - 1) * size, temp, size);
    free(temp);
}

// 实现数组中元素的覆盖
void Cover(void * arr, int i, int j, int size)
{
    memcpy(arr + (i - 1) * size, arr + (j - 1) * size, size);
}

// 数组中元素的下沉方法
void Sink(void *arr, int k, int n, int size)
{
    while (2 * k <= n)
    {
        int j = 2 * k;
        if (j < n && LessArr(arr, j, j + 1, size)) ++j;
        if (!LessArr(arr, k, j, size)) break;
        Exch(arr, k, j, size);
        k = j;
    }
}

// 数组中元素的上浮方法
void Swim(void *arr, int k, int size)
{
    while (k > 1 && LessArr(arr, k / 2, k, size))
    {
        Exch(arr, k, k / 2, size);
        k /= 2;
    }
}

未改进的堆排序（下沉排序）

相比于其他比较或交换类的方法，堆排序的思路不同，它利用了二叉堆的性质，对数组实现原地排序。是一种不稳定的排序算法，这里我们介绍两种思路，一种是基本的下沉排序，另一种是 Floyd 提出的改进策略。

// 基本堆排序的方法
void HeapSort_Basic(void *arr, int n, int size)
{
    for (int k = n / 2; k != 0; --k)
        Sink(arr, k, n, size);
    // 这里如此修改的目的是为了避免一次多余的 Sink
    // 如想简化代码可以将下面 Exch() 一行删掉，再将 while 循环内的两行代码互换
    Exch(arr, 1, n--, size);
    while (n != 1)
    {
        Sink(arr, 1, n, size);
        Exch(arr, 1, n--, size);
    }
}

Floyd 改进策略（先下沉后上浮）

因为大多数重新插入堆的元素会直接加入到堆底，Floyd 发现我们可以免去检查元素是否到达正确位置来节省时间。也就是直接提升较大的子结点直至到达堆底，然后再使元素上浮 🔝 到正确位置。

这样几乎可以将比较的次数减半，接近了对随机数组进行归并排序所需要的比较次数。不过需要额外的空间，在实际应用中只会当比较操作代价高时较高时才会使用（例如对字符串或其他键值较长类型元素进行排序时）。

// Floyd 思路改进后的堆排序方法
void HeapSort_Floyd(void *arr, int n, int size)
{
    for (int k = n / 2; k != 0; --k)
        Sink(arr, k, n, size);
    while (n != 1)
    {
        void * temp = malloc(size);
        memcpy(temp, arr + (n - 1) * size, size);
        Cover(arr, n--, 1, size);
        int k = 1;
        while (2 * k <= n)
        {
            int j = 2 * k;
            if (2 * k < n && LessArr(arr, j, j + 1, size)) ++j;
            Cover(arr, k, j, size);
            k = j;
        }
        memcpy(arr + (k - 1) * size, temp, size);
        Swim(arr, k, size);
        free(temp);
    }
}

排序方法的调用

int main(int argc, char *argv[])
{
    int arr[] = {3,2,1,6,9,4,5,3,2,1,6,7,8,10,13,25,-1,-13,-5,-9};
    int len;
    GET_ARRAY_LEN(arr, len);
    
    HeapSort_Floyd(arr, len, sizeof(int));
    
    for (int i = 0; i < len; ++i) printf("%d ", arr[i]);
    printf("\n");
    
    return 0;
}

完整代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define GET_ARRAY_LEN(arr,len) { len = (sizeof(arr) / sizeof(arr[0])); }

// 比较数组中两个元素大小的方法
int LessArr(void *arr, int i, int j, int size)
{
    return *(int*) (arr + (i - 1) * size) < *(int*) (arr + (j - 1) * size);
}

// 交换数组中两个元素的方法
void Exch(void *arr, int i, int j, int size)
{
    void * temp = malloc(size);
    memcpy(temp, arr + (i - 1) * size, size);
    memcpy(arr + (i - 1) * size, arr + (j - 1) * size, size);
    memcpy(arr + (j - 1) * size, temp, size);
    free(temp);
}

// 实现数组中元素的覆盖
void Cover(void * arr, int i, int j, int size)
{
    memcpy(arr + (i - 1) * size, arr + (j - 1) * size, size);
}

// 数组中元素的下沉方法
void Sink(void *arr, int k, int n, int size)
{
    while (2 * k <= n)
    {
        int j = 2 * k;
        if (j < n && LessArr(arr, j, j + 1, size)) ++j;
        if (!LessArr(arr, k, j, size)) break;
        Exch(arr, k, j, size);
        k = j;
    }
}

// 数组中元素的上浮方法
void Swim(void *arr, int k, int size)
{
    while (k > 1 && LessArr(arr, k / 2, k, size))
    {
        Exch(arr, k, k / 2, size);
        k /= 2;
    }
}

// 基本堆排序的方法
void HeapSort_Basic(void *arr, int n, int size)
{
    for (int k = n / 2; k != 0; --k)
        Sink(arr, k, n, size);
    // 这里如此修改的目的是为了避免一次多余的 Sink
    // 如想简化代码可以将下面 Exch() 一行删掉，再将 while 循环内的两行代码互换
    Exch(arr, 1, n--, size);
    while (n != 1)
    {
        Sink(arr, 1, n, size);
        Exch(arr, 1, n--, size);
    }
}

/* ----------------------------------------------- */

// Floyd 思路改进后的堆排序方法
void HeapSort_Floyd(void *arr, int n, int size)
{
    for (int k = n / 2; k != 0; --k)
        Sink(arr, k, n, size);
    while (n != 1)
    {
        void * temp = malloc(size);
        memcpy(temp, arr + (n - 1) * size, size);
        Cover(arr, n--, 1, size);
        int k = 1;
        while (2 * k <= n)
        {
            int j = 2 * k;
            if (2 * k < n && LessArr(arr, j, j + 1, size)) ++j;
            Cover(arr, k, j, size);
            k = j;
        }
        memcpy(arr + (k - 1) * size, temp, size);
        Swim(arr, k, size);
        free(temp);
    }
}

int main(int argc, char *argv[])
{
    int arr[] = {3,2,1,6,9,4,5,3,2,1,6,7,8,10,13,25,-1,-13,-5,-9};
    int len;
    GET_ARRAY_LEN(arr, len);
    
    HeapSort_Floyd(arr, len, sizeof(int));
    
    for (int i = 0; i < len; ++i) printf("%d ", arr[i]);
    printf("\n");
    
    return 0;
}