排序算法——堆排序

1. 算法概述

　　堆排序（Heap Sort）是指利用堆这种数据结构所设计的一种排序算法，它是选择排序的一种。堆是一个完全的二叉树，分为 最大堆和 最小堆（通常最大堆用于堆排序，最小堆用于构造优先队列）。最大堆要求每个节点的值都不大于其父节点的值，而最小堆要求每个节点的值都要大于其父节点的值。由于堆排序使用最大堆，这里就讲解最大堆。

　　最大堆排序的基本思想：

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]调整为堆。直至无序区只有一个元素。

2. 算法分析

　　最大堆排序算法的基本操作：

1. 建堆，建堆是不断调整堆的过程，从len/2处开始调整，一直到第一个节点，此处len是堆中元素的个数。建堆的过程是线性的过程，从len/2到0处一直调用调整堆的过程，相当于o(h1)+o(h2)+...+o(h len/2)其中好表示节点的深度，len表示节点的个数，这是一个求和的过程，结果是线程的o(n)。
2. 调整堆：调整堆在构建堆的过程中会用到，而且在堆排序过程中也会用到。利用的思想是比较节点i和它的孩子节点，然后left(i),right(i)，选出三者最大（或最小者），如果最大（小）值不是节点i而是它的一个孩子节点，那交换节点i和该节点，然后在调用调整堆过程，这是一个递归的过程。调整堆的过程时间复杂度与堆的深度有关系，是lgn的操作，因为是沿着深度方向进行调整的。
3. 堆排序：堆排序是利用上面的两个过程来进行的。首先是根据原始构建堆。然后将堆的根节点取出（一般是与最后一个节点进行交换），将前面len-1个节点继续进行堆调整的过程，然后再将根节点取出，这样一直到所有节点都取出。堆排序过程的实际复杂度是O(nlgn)。因为建堆的实际复杂度是O(N)（调用一次）；调整堆的时间复杂度是lgn，调用了n-1次，所以堆排序的实际复杂度是O(nlgn)。

3. 算法实现

/*********************************************************************************
*Copyright(C),Your Company
*FileName:  main.cpp
*Author:  Huangjh
*Version:
*Date:  2017-12-21
*Description:  堆排序的实现
*Others:
**********************************************************************************/
#include <stdio.h>

void HeapAdjust(int array[], int iPos, int iLength)
{
	//子节点左孩子的位置 = 2 * 父节点的位置 + 1
	//子节点右孩子的位置 = 2 * 父节点的位置 + 1 + 1
	int iChild = 0;	
	for (int i = iPos; 2 * i + 1 <= iLength; i = iChild)
	{
		//先得出左孩子的位置
		iChild = 2 * i + 1;
		//取左孩子和右孩子较大的那个节点位置
		if (iChild < iLength - 1 && array[iChild + 1] > array[iChild])
			++iChild;
		//如果子节点中有大于父节点的，那么大的那个子节点上浮（与父节点交换）
		if (array[i] < array[iChild])
		{
			int iTemp;
			iTemp = array[i];
			array[i] = array[iChild];
			array[iChild] = iTemp;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int array[], int iLength)
{
	//建堆
	for (int i = iLength / 2 - 1; i >= 0; --i)
		HeapAdjust(array, i, iLength);
	//堆排序的过程
	for (int i = iLength - 1; i > 0; --i)
	{
		//将根节点取出，与最后一个节点进行交换，
		//将前面iLength - 1个节点进行堆调整，然后在将
		//根节点取出，一直到所有节点都取出
		//这里就是进行两个数的交换,最大的已经放到位置i
		array[i] = array[0] ^ array[i];
		array[0] = array[0] ^ array[i];
		array[i] = array[0] ^ array[i];
		//将array[0,...i - 1]重新调整为最大堆
		HeapAdjust(array, 0, i - 1);

	}
}

int main(void)
{
	int szBuffer[] = { 49, 38, 65, 97, 76, 13, 27, 49 };

	HeapSort(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]) - 1);

	printf("堆排序后的输出:\r\n");
	for (int i = 0; i < sizeof(szBuffer) / sizeof(szBuffer[0]) - 1; i++)
	{
		printf("%d ", szBuffer[i]);
	}
	printf("\r\n");

	return 0;
}

　　运行结果如下所示：

堆排序后的输出:
13 27 49 49 65 76 97