《算法导论》学习笔记（1）——堆与堆排序

         堆排序( Heapsort )是指利用“堆”这种数据结构所设计的一种排序算法。

         堆是一种数据结构，是一个数组。它可以被看成一个近似的完全二叉树，树上的每一个结点对应数组中的一个元素。除了最底层外，即叶子结点，该树是完全充满的，而且是从左到右填充。

         最大堆的每个结点都要满足堆的性质，此外还有其他的约束：堆中的最大元素存放在根结点中，并且在任一子树中，该子树所包含的所有结点的值都不大于该子树根结点的值。

         堆排序就是利用最大堆的性质来排序。大致步骤如下：

         ①建最大堆

         ②将根结点（最大元素）与最后一个结点的元素互换，并将剩下的结点维护最大堆的性质。

         ③重复步骤②，直到将每个元素排完序。

下面就讲解几个重要过程：

         维护最大堆的性质：MaxHeapify

         传入参数：待排序数组、需要维护的下标、当前堆的大小。返回值：空

         每次在传入参数的下标、该下标的左、右孩子结点三者中选出最大的元素。如果最大元素是该下标，则满足最大堆性质，结束。否则，需要将父亲与最大的孩子交换位置，使得当前下标及其左右孩子满足最大堆的性质。之后递归调用，使得整个子树都满足最大堆的性质。

         特别需要注意，数组的大小和堆的大小是不一样的概念。堆的大小表示有多少个堆元素存储在数组中。在进行堆排序的过程中，每次需要把根结点元素与最后一个元素交换，这样堆的大小每次就会减一。而数组大小是不会变的。也就是：

0 ≤ 堆的大小 ≤ 数组的大小

                                                              

         建最大堆：BuildMaxHeap

         传入参数：待排序数组、当前堆的大小。返回值：空

         只需保证所有的非叶子结点满足最大堆的性质即可。非叶子结点的下标为从0到堆大小 / 2（向下取整）。

                 

         堆排序：HeapSort

         传入参数：待排序数组、当前堆的大小。返回值：空

         首先建堆，然后每次去除根结点元素（最大元素），然后维护最大堆的性质。如此循环，直到所有元素排序完毕。

         实现代码如下：

#include <iostream>
using namespace std;

typedef int ElemType;

int getLeftChild( int i ) //返回左孩子下标。注：数组从位置0开始
{
	return 2 * i + 1;
}

int getRightChild( int i ) //返回右孩子下标。注：数组从位置0开始
{
	return 2 * i + 2;
}

void swap( ElemType *a, ElemType *b ) //交换两个元素
{
	ElemType temp = *a;
	*a = *b;
	*b = temp;
}

/* 维护最大堆的性质。
 * 参数：待排序数组、需要维护的下标、当前堆的大小
 * 返回值：空
 */
void MaxHeapify( ElemType *A, int i, int num )
{
	int left = getLeftChild( i );
	int right = getRightChild( i );
	int largest; // 存放父结点、左右子节点三者的最大值的下标位置
	if( left <= num && A[left] > A[i] )
		largest = left;
	else
		largest = i;
	if( right <= num && A[right] > A[largest] )
		largest = right;
	if( largest != i )
	{
		swap( &A[i], &A[largest] );
		MaxHeapify( A, largest, num );
	}
}

/* 建最大堆
 * 传入参数：待排序数组、当前堆的大小
 * 返回值：空
 */
void buildMaxHeap( ElemType *A, int num )
{
	for( int i=num/2; i>=0; i-- )
		MaxHeapify( A, i, num );
}

/* 堆排序
 * 待排序数组、当前堆的大小
 * 返回值：空
 */
void heapSort( ElemType *A, int num )
{
	buildMaxHeap( A, num-1 );
	int HeapSize = num - 1; //当前堆的大小
	for( int i=num-1; i>0; i-- )
	{
		swap( &A[0], &A[i] );
		HeapSize--;
		MaxHeapify( A, 0, HeapSize );
	}
}

int main()
{
	ElemType A[10] = {1,3,6,2,4,8,0,9,7,5};
	heapSort( A, 10 );
	for( int j=0; j<10; j++ )
		cout << A[j] << " ";
	cout << endl;
	return 0;
}

时空复杂度：

    由于每次重新恢复堆的时间复杂度为O(logN)，共N - 1次重新恢复堆操作，再加上前面建立堆时N / 2次向下调整，每次调整时间复杂度也为O(logN)。二次操作时间相加还是O(N * logN)。故堆排序的时间复杂度为O(N * logN)。

    由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。

    堆排序是就地排序，辅助空间为O(1）， 它是不稳定的排序方法。