堆排序

#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);
}
}