堆排序

堆是一棵完全二叉树，其任一非叶结点的关键字不小于（最大堆而言）或不大于（最小堆而言）其左右孩子节点的关键字。

假设待排序数组为A[]，那么初始的话我们可以按层次编号建树，对结点i（从零开始）而言，其左右结点分别为2*i+1、2*i+2。

堆排序的算法可大致描述如下：

1.建立最大堆（或最小堆）；

2.

for(i = heapSize -1; i > 0; i --)
{
    swap(A[i], A[0]);
    heapSize --;
    RestoreHeap(A, 0);           
}

堆排序整体代码如下：

#include <iostream>
#include <cstdlib>
using namespace std;
int heapSize;
void swap(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}
void RestoreHeap(int *A, int i)
{
    int l = 2*i + 1;
    int r = 2*i + 2;
    int great;
    if(l < heapSize && A[l] > A[i])
        great = l;
    else 
        great = i;
    if(r < heapSize && A[r] > A[great])
        great = r;
    if (great != i)
    {
        swap(A[i], A[great]);
        RestoreHeap(A, great);
    }
}
//非递归Restore算法
void Restore(int *A, int i)
{
    int j = i;
    int l, r, great;      
    while(j <= heapSize/2 - 1)
    {
        l = 2*j + 1;
        r = 2*j + 2;
        if(r < heapSize && A[l] < A[r])
            great = r;
        else 
            great = l;
        if(A[great] > A[j])
        {
            swap(A[great], A[j]);
            j = great;
        }
        else
            break;
    }
}
void BuildMaxHeap(int *A)
{
    for(int i = heapSize/2 - 1; i >= 0; i--)
        //RestoreHeap(A, i);
        Restore(A, i);
}
void HeapSort(int *A)
{
    BuildMaxHeap(A);
    for(int i = heapSize - 1; i > 0; i--)
    {
        swap(A[i], A[0]);
        heapSize --;
        //RestoreHeap(A, 0);
        Restore(A, 0);
    }
}
int main()
{
    int *A = NULL;
    cout<<"Input heap size and its values:"<<endl;
    while(cin>>heapSize && heapSize)
    {
        try
        {
            A = new int[heapSize];
        }
        catch(const bad_alloc &e)
        {
            cerr<<"bad alloc error:"<<e.what()<<endl;
            abort();
        }
        int i;
        for(i = 0; i < heapSize; i++)
        {
            cin>>A[i];
        }
        int size = heapSize;
        HeapSort(A);
        cout<<"After sort:"<<endl;
        for(i = 0; i < size; i++)
            cout<<A[i]<<" ";
        cout<<endl<<"Input heap size and its values:"<<endl;
        delete A;
        A = NULL;
    }
    return 0;
}

堆排序是不稳定的排序，因为在重建堆的时候并没有考虑原来的顺序，即便关键字相同的元素也有可能进行交换。