MIT：算法导论——4.1.排序和顺序统计量_堆排序

【排序问题】
输入：一个n个数的序列<a1, a2, ..., an>。
输出：输入序列的一个排列（重排）<a1', a2', ..., an'>，使得a1' <= a2' <= ... an'。
输入序列通常是一个n元数组，尽管它可以用链表等其他方式描述。
【为什么要排序】
很多计算机科学家认为 排序是算法研究中最基础的问题。
【插入排序】
由于其内层循环非常紧凑，对于 小规模输入，插入排序是一种非常快的原址排序算法。
如果输入数组中仅有常数个元素需要在排序过程中存储在数组之外，则成排序算法是原址的(in place)。
【空间原址性】任何时候都只需要常数个额外的元素空间存储临时数据。
【比较排序算法】
插入排序、归并排序、快速排序、堆排序等都是比较排序算法——
通过对元素进行比较操作 来确定输入数组的有序次序。
比较排序算法的排序n个元素的最坏情况运行时间的下界为Ω(nlgn)。
【线性时间排序】
采用比较操作之外的方法来获得输入序列有序次序的信息，以打破Ω(nlgn)的下界，以获得线性时间O(n)。
计数排序：O(n+k)，数值集合为{0, 1, ..., k}；当k=O(n)时，可以获得线性运行时间。
基数排序：O(d(n+k))，每个整数有d位，每个数字可能取k值；当d是常数且k=O(n)时，其运行时间为线性的。
桶排序：O(n)，当n个实数在半开区间[0, 1)内服从均匀分布的n个实数，桶排序的平均情况运行时间为O(n)。
【顺序统计量】
一个n个数的集合的 第i个顺序统计量就是集合中第i小的数。
当不知道其顺序，先排序再输出第i个元素的方式，运行时间为Ω(nlgn)。
****************************************************
【堆】
A[1...n],树的根结点为为A[1]，这样容易计算得到父节点、左孩子、右孩子。
在堆排序的好的实现中，下面这三个函数通常是以宏或者内联函数的方式实现的：
#define PARENT( i ) ( i >> 1 )
#define LEFT( i )   ( i << 1 )
#define RIGHT( i )  ( i << 1 + 1)
【最大堆】A[PARENT( i )] >= A[i]
【最小堆】A[PARENT( i )] <= A[i]
最大堆性质：
（1）堆中最大元素在根结点中；且任一子树中，该子树包含的所有结点的值都不大于该子树根结点的值。
（2）含n个元素的堆的高度为lgn下取整。
（3）当用数组存储n个结点时，最后一个非叶节点为[n/2」 = PARENT( n )。

#if 1
#include <iostream>

using namespace std;

#define PARENT( i ) ( i >> 1 )
#define LEFT( i )   ( i << 1 )
#define RIGHT( i )  ( i << 1 + 1)

//（1）MAX-HEAPIFY过程：其时间复杂度为O(lgn)，它是维护最大堆性质的关键。
template<typename T>
void max_heapify( T a[], int i, int heap_size )
{// 可以将heap_size集成到包含T a[]的堆类中
	int c;
	T data;
	
	data = a[i];
	c = LEFT( i );
	while( c <= heap_size ){
		if( c < heap_size && a[c] < a[c+1] )
			++c;
		if( data >= a[c] )
			break;
		a[PARENT(c)] =a[c];// 自己编程遗忘了这一步
		c = LEFT( c );
	}
	a[PARENT(c)] = data;
}
//（2）BUILD-MAX-HEAP过程：具有线性时间复杂度；O(nlgn)-->O(n)
//     功能是从无序的输入数据数组中构造一个最大堆。
template<typename T>
void build_max_heap( T a[], int heap_size )
{
	if( a == NULL || heap_size <= 1 )
		return;

	for( int i =  PARENT( heap_size ); i >= 1; --i ){
		max_heapify( a, i, heap_size );
	}
}

//（3）HEAPSORT过程：其时间复杂度为O(nlgn)，功能是对一个数组进行原址排序
template<typename T>
void heap_sort( T a[], int heap_size )
{
	build_max_heap( a, heap_size );
	for( int i = heap_size; i >= 2; --i ){
#if defined( TEST )
		for( int j = 1; j <= heap_size; ++j )
			cout << a[j] << " ";
		cout << endl;
#endif

		T tmp = a[1];
		a[1] = a[i];
		a[i] = tmp;
		max_heapify( a, 1, i - 1 );
		//max_heapify( a, i, heap_size );
	}
}

//（4）MAX-HEAP-INSERT
template<typename T>
void max_heap_insert( T a[], int heap_size, int max_size, T& data )
{
	if( heap_size == max_size )
		return;// throw out_of_bounds("NoMem");

	int c = ++heap_size;
	while( c != 1 && a[PARENT(c)] < a[c] ){
		a[c] = a[PARENT(c)];
		c = PARENT(c);
	}
	a[c] = data;
}

int main( void )
{
	int a[] = { 0, -3, -25, 20, -3, -16, -23, 18, 20, -7, 12, -5, -22, 15, -4, 7 };
	heap_sort<int>( a, sizeof(a) / sizeof(int) - 1 ); 
	for( int i = 1; i < sizeof( a ) / sizeof( int ); ++i )
		cout << a[i] << " ";
	cout << endl;
}

#endif