堆排序

最小堆为降序排列，最大堆为升序排列

#include <iostream>

using namespace std;
void MinHeapify(int* A, int parentIndex, int heapSize);
void Swap(int* A, int lIndex, int rIndex);
void BuildMinHeap(int* A, int len);
void HeapSort(int* A, int len);

int main ()
{
    int arr[] = {3,1,5,2,4,99,8,7};
    int len = sizeof(arr)/sizeof(arr[0]);
    HeapSort(arr, len);
    for (int i = 0; i < len; ++i)
    {
        cout << arr[i] << "\t";
    }
    cout << endl;
    return 0;
}

void MinHeapify(int* A, int parentIndex, int heapSize)
{
    int leftChildIndex = 2*parentIndex+1;
    int rightChildIndex = leftChildIndex+1;

    int minIndex = parentIndex;

    if (leftChildIndex < heapSize && A[leftChildIndex] < A[parentIndex])
    {
        minIndex = leftChildIndex;
    }

    if (rightChildIndex < heapSize && A[rightChildIndex] < A[minIndex])
    {
        minIndex = rightChildIndex;
    }

    if (minIndex != parentIndex)
    {
        Swap(A, parentIndex, minIndex);
        MinHeapify(A, minIndex, heapSize);
    }
}

void Swap(int* A, int lIndex, int rIndex)
{
    int tmp = A[lIndex];
    A[lIndex] = A[rIndex];
    A[rIndex] = tmp;
}

void BuildMinHeap(int* A, int len)
{
    if (A == NULL || len < 1)
    {
        return;
    }

    for (int i = len/2; i >= 0; i--)
    {
        MinHeapify(A, i, len);
    }
}

void HeapSort(int* A, int len)
{
    if (A == NULL || len < 1)
    {
        return;
    }
    BuildMinHeap(A, len);

    for (int i = len-1; i > 0; --i)
    {
        Swap(A, i, 0);

        MinHeapify(A,0,i);
    }
}