排序算法之堆排序

堆排序，原地排序算法，时间复杂度O(nlog n)，不稳定的排序算法

数组实现

inline int Parent(int i)
{
	return (i-1)/2;//以数组下标为0开始计算，如以1开始计算则为i/2
}
inline int Left(int i)
{
	return (2*i+1);//以数组下标为0开始计算，如以1开始计算则为2*i
}
inline int Right(int i)
{
	return 2*(i+1);//以数组下标为0开始计算，如以1开始计算则为2*i+1
}

template<class T>
void MaxHeap(T A[], int i,int heap_size)
{
	int l=Left(i);
	int r=Right(i);
	int largest;
	if(l<heap_size && A[l]>A[i])//以1开始计数则应为l<=heap_size
		largest = l;
	else
		largest = i;
	if(r<heap_size && A[r]>A[largest])//以1开始计数则应为r<=heap_size
		largest = r;
	if(largest != i)
	{
		swap(A[i],A[largest]);
		MaxHeap(A,largest,heap_size);
	}
}

template<class T>
void BuildMaxHeap(T A[],int len)
{
	int heap_size = len;//堆中元素数量
	for(int i = Parent(len-1);i>=0;i--)
		MaxHeap(A,i,heap_size);
}

template<class T>
void HeapSort(T A[],const int len)
{
	int heap_size = len;
	BuildMaxHeap(A,heap_size);
	for(int i=len-1;i>=0;i--)
	{
		swap(A[0],A[i]);
		--heap_size;
		MaxHeap(A,0,heap_size);
	}
}