堆排序(Heap Sort)

维基百科：http://zh.wikipedia.org/wiki/堆排序

1、基本知识

二叉堆一般用数组来表示，我们可以把它视为一颗完全二叉树。数据结构中学习树这一章节时，我们知道完全二叉树可以用数组来存储。

堆的定义：

（1）大根堆：父节点的值大于等于孩子结点的值

（2）小根堆：父节点的值小于等于孩子结点的值

父节点和孩子结点下标的计算

（1）假设用数组A[1..n]来存储完全二叉树，即下标从1开始

结点i的父节点：i/2 (向下取整)
结点的左孩子结点：2*i（如果存在）
结点的右孩子结点：2*i + 1(如果存在)

（2）假设用数组A[0..n-1]来存储完全二叉树，即下标从0开始

结点i的父节点：（i-1）/2
结点i的左孩子结点： 2 * i +1（如果存在）
结点的右孩子结点：2 * i + 2（如果存在）

2、算法思想

以对数组进行升序排序为例，可以把数组建为一个大根堆，然后不断输出堆顶元素， 并调整堆，直至输出所有元素。这里采取的是数组首元素和尾元素交换，也就是把最大元置于数组尾部，每一次都可以确定一个元素的最终位置，显然堆排序算法属于原地排序。

3、代码实现

下面的代码是根据算法导论中的伪代码编写的，代码中有详细的注释。

#include <cstdlib>
#include <iostream>

using namespace std;

//父节点下标
int parent(int i)
{
return (i - 1)/2;
}

//左孩子下标
int leftChild(int i)
{
return (2 * i + 1);
}

//右孩子下标
int rightChild(int i)
{
return (2 * i + 2);
}

/*调整下标为i的结点的位置，使以其为根的子树为大根堆
假定该函数被调用时，以left(i)和right(i)为根的两棵二叉树都是大根堆
*/
template<class T>
void maxHeapify(T* a, int i, int heapSize)
{
int largest = -1;           //记录a[i]和其子女(如果存在)中最大者小标
int left = leftChild(i);
int right = rightChild(i);

if(left < heapSize && a[left] > a[i])
{
largest = left;
}
else
{
largest = i;
}

if(right < heapSize && a[right] > a[largest])
{
largest = right;
}

if(i != largest)
{
swap(a[i], a[largest]);
maxHeapify(a,largest,heapSize);
}
}

//把一个数组构建为大根堆
template<class T>
void buildMaxHeap(T* a, int heapSize)
{
int i = heapSize/2 -1;          //最后一个非叶子结点下标
for(; i>=0; i--)
{
maxHeapify(a, i, heapSize);//从最后一个非叶子结点开始自底向上调整堆
}
}

//堆排序
template<class T>
void heapSort(T* a, int n)
{
int heapSize = n;
buildMaxHeap(a, heapSize);//
// 把最大元素(堆顶元素)和堆尾元素交换，堆的大小减1，从堆顶开始自顶向下调整堆
//重复以上操作直到堆的大小为1
for(int i=n-1; i>0; i--)
{
swap(a[0],a[i]);
heapSize--;
maxHeapify(a,0,heapSize);
}
}

int main(int argc, char *argv[])
{
int n;
int *a = NULL;

while(cin>>n && n > 0)
{
a = new int
;
for(int i=0; i<n; i++)
{
cin>>a[i];
}
heapSort(a,n);
for(int i=0; i<n; i++)
{
cout<<a[i]<<" ";
}
cout<<endl<<endl;
delete [] a;
}

system("PAUSE");
return EXIT_SUCCESS;
}

4、复杂度分析

(1)对于大小为n的数组，堆的高度为lgn，

(2)调整函数maxHeapify的复杂度为O(h)，即O(lgn)。

(3)heapSort中循环执行O(n)次，因而算法复杂度为O(nlgn)

算法时最坏情况下和平均情况下的时间复杂度都为O(nlogn)，堆排序是渐进最优的排序算法。

参考资料：

[1]算法导论（第2版）

[2]严蔚敏《数据结构(C语言版)》