排序算法之堆排序

1、堆

以二叉堆为例（堆也可以使用单链表来实现），堆其实是一个完全二叉树，因此可以用一个数组来存储，任何非叶子结点满足：

最大堆 key[i]>=key[2*i+1] && key[i]>=key[2*i+2]；  最小堆 key[i]<=key[2*i+1] && key[i]<=key[2*i+2]

即任何一个非叶子结点的元素不小于或者不大于左右子节点。

2、堆排序

利用最大堆（最小堆）堆定记录的是最大（最小）元素这一性质，每次从无序序列中取出最大（最小）加入有序序列进行排序（有点儿像选择排序，只是选出元素的方式不同）。

堆排序思想（最大堆）：

（1）将待排序序列{R[0]、R[1]、R[2]...R[n-1]}构建成最大堆，此堆为初始的无需序列

（2）将堆顶元素R[0]与无序序列最后一个元素R[n-1]交换，此时得到新的无需序列{R[0]、R[1]...R[n-2]}和有序序列{R[n-1]}

（3）交换后的堆顶元素R[0]可能会破坏堆的性质，因此需要调整当前无序序列{R[0]、R[1]...R[n-2]}为堆。然后再次将堆顶元素R[0]与无序序列最后一个元素R[n-2]交换，得到新的无序序列{R[0]、R[1]...R[n-3]}和有序序列{R[n-2]、R[n-1]}。不断进行这个过程，直到有序序列有n-1个元素。

3、实现：时间复杂度O(nlogn)，空间复杂度O(1)，不稳定

#include<iostream>

using namespace std;

/*堆排序，基于最大堆，得到升序*/
//调整堆，单个节点的调整
void MaxHeapAdjust(int *pData, int i, int heap_size)
{
	int left = 2*i+1;
	int right = 2*i+2;
	int largest = i, tmp;

	if(left<heap_size && pData[left]>pData[largest])
	{
		largest = left;
	}
	if(right<heap_size && pData[right]>pData[largest])
	{
		largest = right;
	}

	if(i!=largest)
	{
		tmp = pData[i];
		pData[i] = pData[largest];
		pData[largest] = tmp;
		MaxHeapAdjust(pData, largest, heap_size);   //交换后的子节点可能破坏堆，继续调整
	}
}
//建最大堆
void BuildMaxHeap(int *pData, int heap_size)
{
	for(int i=(heap_size-2)/2;i>=0;i--)   //最大非叶子结点位于heap_size-2)/2
	{
		MaxHeapAdjust(pData,i,heap_size);
	}
}
//最大堆排序
void HeapSort(int *pData, int count)
{
	int i,tmp;
	BuildMaxHeap(pData,count);

	for(i=count-1;i>=0;i--)
	{
		tmp = pData[i];
		pData[i] = pData[0];
		pData[0] = tmp;

		MaxHeapAdjust(pData,0,i);
	}
}

int main()
{
	int data[7] = {6,8,5,9,4,7,3};
	HeapSort(data,7);
	//输出有序数组
	for(int k=0;k<7;k++)
	{
		cout<<data[k]<<endl;
	}

	return 0;
}