最大堆排序

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

通常堆是通过一维数组来实现的。在起始数组为 0 的情形中：

          父节点i的左子节点在位置 (2*i+1);

          父节点i的右子节点在位置 (2*i+2);

          子节点i的父节点在位置 floor((i-1)/2);

在堆的数据结构中，堆中的最大值总是位于根节点。堆中定义以下几种操作：

          最大堆调整（Max_Heapify）：将堆的末端子结点作调整，使得子结点永远小于父结点

          创建最大堆（Build_Max_Heap）：将堆所有数据重新排序

          堆排序（HeapSort）：移除位在第一个数据的根结点，并做最大堆调整的递归运算

#include <stdio.h>

void SwapValue(int *OperatorA, int *OperatorB)
{
    if ((NULL == OperatorA) || (NULL == OperatorB))
    {
        printf ("Invalid Parameter(s)!\n");
        return;
    }

    if ((*OperatorA) != (*OperatorB))
    {
        *OperatorA ^= *OperatorB;
        *OperatorB ^= *OperatorA;
        *OperatorA ^= *OperatorB;
    }
}

// 最大堆排序，升序
// 向上调整成最大堆
void MaxHeapFixUp(int *a, int l)
{
    if ((NULL == a) || (l < 0))
    {
        printf ("Invalid Parameter(s)!\n");
        return;
    }

    int nTemp = a[l];
    int i = l;
    int j = (i - 1) / 2;

    while (j >= 0)
    {
        if (a[j] >= nTemp)
        {
            break;
        }

        a[i] = a[j];
        i = j;
        j = (i - 1) / 1;
    }

    a[i] = nTemp;
}

// 简化代码的向上调整
void MaxHeapFixUp1(int *a, int l)
{
    if ((NULL == a) || (l < 0))
    {
        printf ("Invalid Parameter(s)!\n");
        return;
    }

    int nTemp = a[l];
    int i;
    int j;
    
    for (i = l, j = (i - 1) / 2; (j >= 0) && (a[j] < nTemp); i = j, j = (i - 1) / 2)
    {
        SwapValue (&a[i], &a[j]);
    }
}

// 向下调整
void MaxHeapFixDown(int *a, int l, int N)
{
    if ((NULL == a) || (l < 0) || (l >= N))
    {
        printf ("Invalid Parameter(s)!\n");
        return;
    }

    int nTemp = a[l];
    int i = l;
    int j = 2 * i + 1;

    while (j < N)
    {
        if (((j + 1) < N) && (a[j+1] > a[j]))
        {
            ++j;
        }

        if (a[j] <= nTemp)
        {
            break;
        }

        a[i] = a[j];
        i = j;
        j = 2 * i + 1;
    }

    a[i] = nTemp;
}

// 将数组转换成最大堆存储
void ShiftToMaxHeap(int *a, int N)
{
    if ((NULL == a) || (N <= 0))
    {
        printf ("Invalid Parameter(s)!\n");
        return;
    }

    for (int i = N / 2 - 1; i >= 0; --i)
    {
        MaxHeapFixDown (a, i, N);
    }
}

// 最大堆排序
void MaxHeapSort(int *a, int N)
{
    if ((NULL == a) || (N <= 0))
    {
        printf ("Invalid Parameter(s)!\n");
        return;
    }

    for (int i = N - 1; i >= 1; --i)
    {
        SwapValue (&a[0], &a[i]);
        MaxHeapFixDown (a, 0, i);
    }
}

int main(void)
{
    int a1[9] = {9, 8, 7, 6, 5, 4, 3, 2, 1};

    MaxHeapSort (a1, 9);

    for (int i = 0; i < 9; ++i)
    {
        printf ("%d ", a1[i]);
    }

    printf ("\n");

    return 0;
}