堆排序(参考大话数据结构)

        堆排序是一种非稳定的排序，属于选择排序类，它的核心是要构建一个大顶堆或者是小顶堆，以大顶堆为例，根节点的值为最大值，交换到数组的最后，然后对1至n-1的元素继续构建一个大顶堆，再将根节点与第n-1个元素交换，如此循环，直到最后数组为有序。

        首先定义要用到的结构：

#define MAXSIZE 10
typedef struct
{
       int r[MAXSIZE + 1];
       int length;
}SqList;

void swap(SqList *L, int i, int j)
{
      int temp = L->r[i];
      L->r[i] = L-r[j];
      L->r[j] = temp;
}

       swap函数在定义的堆排序函数中会用到，交换下标为i和下标为j的元素

       再定义函数HeapAdjust(SqList *L, int s, int ),函数的定义如下：

void HeapAdjust(SqList *L, int s, int m)
{
	int temp, j;
	temp = L->r[s];
	for(j = 2*s; j <=m; j *=2)
	{
		if(j < m&&L->r[j] < L->r[j+1])  
			++j;
		if(temp >=L->r[j])              
			break;
		L->r[s] = L->r[j];
		s = j;
	}
	L->r[s] = temp;
}

 数组结构L中除了关键字L->r[s]的元素之外，从L->r[s+1]到L->r[m]的元素的排列和顺序均满足最大（小）堆的定义，HeapAdjust函数的功能就是将数组L中从L->[s]到L->[m]的元素调整成最大（小）堆，循环开始的时候j的初始值是2*s，实际上j从s的左孩子开始，然后将左孩子和右孩子中较大的那一个传递给s，之所以有循环是因为当当前的根节点s和其孩子交换之后，若孩子节点还有子结点（通过判断式j<=m来判断），需要继续向下来比较，将较大的值传上来，一直向下直到传到整个树的结尾（j>m）或者是初始的根节点s的值（temp>=L->r[j]）已经是最大为止。

        再来看看整个堆排序的代码：

void HeapSort(SqList *L)
{
	int i;
	for(i = L->length/2; i>0; --i)
		HeapAdjust(L,i, L->length);

	for(i=L->length;i>1; --i)
	{
		swap(L, 1, i);
		HeapAdjust(L, 1, i-1);
	}
}

第一部分循环从非叶子结点的最大编号的结点开始（元素L->length/2），逐渐向上构建出一个大顶堆序列。

然后再来看看第二部分，第一部分的代码已经将整个序列调整成一个大顶堆的结构，然后我们可以知道根节点是整个结构中元素值最大的结点，将根结点和最后一个结点进行交换swap(L, 1, length)，这个时候最后一个元素的值是整个数组中的最大值。然后再将1至length-1的元素调整成大顶堆。这是第一次循环。

        第二次循环开始，i = length -1，第一次循环之后，1至length-1编号的元素已经是大顶堆结构，swap（L，1，length-1），将原结构L中次大的元素调到length-1的位置，然后HeapAdjust(L,1, length-2)将1至length-2序号的元素调整成大顶堆结构准备下一次循环。

       。。。。。。。。。。。

       最后结束之后整个数组就是一个有序数组了。

      检测代码：

	SqList*L = new SqList;
	L->length = 9;
	L->r[0] = 0;
	L->r[1] = 50;
	L->r[2] = 10;
	L->r[3] = 90;
	L->r[4] = 30;
	L->r[5] = 70;
	L->r[6] = 40;
	L->r[7] = 80;
	L->r[8] = 60;
	L->r[9] = 20;
	HeapSort(L);
	for(int i = 1; i<=9; ++i)
		cout << L->r[i] <<" ";
	cout << endl;
	return 0;

运行结果：

堆排序的时间复杂度0（nlogn），优于冒泡，简单选择，直接插入排序，在大规模的数组排序中有优势，但是由于其建堆次数比较多，不适合排序序列个数较少的情况。