排序算法之堆排序

前言：今天我来介绍下堆排序，在写堆排序代码之前，我们要知道堆的概念！

　　堆的定义：n个关键字序列Kl，K2，…，Kn称为（Heap），当且仅当该序列满足如下性质（简称为堆性质）：

　　(1)ki<=k(2i）且ki<=k(2i+1)(1≤i≤ n），当然，这是小根堆，大根堆则换成>=号。//k(i）相当于二叉树的非叶子结点，K(2i）则是左子节点，k(2i+1）是右子节点

若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：
　　树中任一非叶子结点的关键字均不大于（或不小于）其左右孩子（若存在）结点的关键字。

　　堆的分类：

　　　　1).大根堆和小根堆：根结点（亦称为堆顶）的关键字是堆里所有结点关键字中最小者的堆称为小根堆，又称最小堆。

　　　　2).根结点（亦称为堆顶）的关键字是堆里所有结点关键字中最大者，称为大根堆，又称最大堆。

　　　　注意：①堆中任一子树亦是堆。②以上讨论的堆实际上是二叉堆（Binary Heap），类似地可定义k

　　堆排序的思想：　　　

　　　　1).先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区

　　　　2).再将关键字最大的记录R[1]（即堆顶）和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key

　　　　3).由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。

　　堆排序的参考代码：

　　以下代码参考算法导论和百度百科！

//堆排序，伪代码
// HEAPSORT(A)
// BUILD-MAX-HEAP(A)
// for i=A.length downto 2
//       exchange A[1] with A[i]    //将第一个元素和第i个元素交换
// A.heap-size = A.heap-size - 1;
// MAX-HEP-APIFY(A,1);

void heapAdjust(int iarr[],int start,int len)
{
    int i = start,temp = 0,maxChildIndex = 0;
    for(;i < len / 2; ++i)
    {
        maxChildIndex = 2*i+1;
        if(maxChildIndex + 1 < len)    //如果右节点存在
        {
            maxChildIndex = iarr[maxChildIndex] > iarr[maxChildIndex + 1] ? maxChildIndex: maxChildIndex + 1;
        }
        if(iarr[i] < iarr[maxChildIndex])
        {
            temp = iarr[maxChildIndex];
            iarr[maxChildIndex] = iarr[i];
            iarr[i] = temp;
        }
    }
}
void heapSort(int iarr[],int len)
{
    int i,temp;
    //开始的时候建堆，根据堆的性质，从原始数组的最后一个元素的父节点开始调整即可
    for(i = len / 2; i > 0; --i)
    {
        heapAdjust(iarr,i - 1,len);
    }
    for(i = 0;i < len; ++i)
    {
        cout << iarr[i] << " ";
    }
    cout << endl;
    for(i = len - 1; i > 0; --i)
    {
        //堆的最后一个元素与第一个元素交换
        temp    = iarr[i];
        iarr[i] = iarr[0];    
        iarr[0] = temp;
        heapAdjust(iarr,0,i);
    }
}
int main()
{
    int a[10]={4,1,3,2,16,9,10,14,8,7};
    heapSort(a,10);
    for(int i=0;i < 10; ++i)
        cout << a[i] << " ";
    return 0;
}

算法分析：

　　堆排序的时间，主要由建立初始堆和反复重建堆这两部分的时间开销构成，它们均是通过调用heapAdjust实现的。

　　平均性能：O(N*logN) = O(N)(heapSort中的两个for循环的时间复杂度)*O(lonN)(heapAdjust中的for循环的时间复杂度)。

　　由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。

　　堆排序是就地排序，辅助空间为O(1）.

　　它是不稳定的排序方法。