排序算法 之 堆排序（heapsort）

堆

（二叉）堆数据结构是一种数组对象，可以被视为一棵完全二叉树。树的每一层都是填满的，最后一层可能除外。

二叉堆有两种：最大堆和最小堆。

最大堆中，除了根节点以外的每个节点i，有A[PARENT(i)]>=A[i]。这样，堆中的最大元素就存放在根节点中。

最小堆中，除了根节点以外的每个节点i，有A[PARENT(i)]<=A[i]。这样，堆中的最小元素就存放在根节点中。

堆排序

堆排序的算法主要分为三个要素：

1、确保最大（最小）堆的特性：从某节点i开始，判断i与其两个子节点的大小关系，对于最大堆来说，i节点如果大于其两个子节点的值，则结束程序；若小于某一个，则找出最大的替换为父节点，并将小的换到子节点处，并对该节点重复以上操作。该操作可以将位于i位置的较小（较大）值替换到二叉树的低端。值得注意的是，该步骤仅仅是对一个节点的操作，是确保的最大（最小）特性的单元操作。建堆时，需要用循环重复本要素。

2、根据数组建堆：从数组的n/2 -1 到 0，依次对该元素进行要素1操作，以确保所建堆为最大（最小）堆。

3、堆排序：逐一将顶端元素替换到最低端，将最低端元素移动到树顶，并使heap_size减小，从而使被移到低端的该元素退出以后的堆操作。每次移动后，重新对树顶节点进行要素1操作，由于除树顶外，其他部分都已经符合最大（最小）堆特性，因此该步骤可以将树顶元素重新移动到低端，形成新的最大（最小）堆。重复以上操作，直至堆消失。则排序后的数组就是一个升序（降序）数组。

以下算法讨论以最大堆为例,排出的数组位升序，最小堆排序将max_heapify()函数做更改即可。

堆积排序

分类	排序算法
数据结构	数组
最差时间复杂度	O(nlogn)
最优时间复杂度	O(nlogn)[1]
平均时间复杂度	Θ(nlogn)
最差空间复杂度	O(n) total, O(1)auxiliary
最佳算法	不是

C实现

int parent(int i)
{
return (i-1)/2;
}
int lchild(int i)
{
return 2*i+1;
}
int rchild(int i)
{
return 2*(i+1);
}
/*保持堆的性质*/
/*最大堆*/
void max_heapify(int A[], int i, int heap_size)
{
int temp,largest;
int l,r;
l = lchild(i);
r = rchild(i);
if( ( l < heap_size ) && ( A[l] > A[i] ) )
largest  = l;
else
largest  = i;
if( ( r < heap_size ) && ( A[r] > A[largest] ) )
largest = r;
if( largest != i )
{
temp = A[i];
A[i] = A[largest];
A[largest] = temp;
max_heapify(A,largest,heap_size);
}
}
/*根据数组建堆*/
void built_heap(int A[], int length)
{
int i;
for( i = length/2 - 1; i >= 0; i--)		//对于A
来说，A[n/2 ... n-1]的元素，都是树中的叶子
//建堆的过程是从叶子的上一层开始，逐次向上直至树顶
{
max_heapify(A,i,length);			//此处直接将数组长度传入
}
}
/*堆排序算法*/
void heap_sort(int A[], int length)
{
int i;
int temp;
int heap_size;
heap_size = length;
built_heap(A,length);
for( i = length-1; i >= 1; i--)
{
temp = A[0];
A[0] = A[i];
A[i] = temp;
heap_size--;
max_heapify(A, 0, heap_size);
}

}

测试文件&结果

#include <stdio.h>
#include <tchar.h>
#include <stdlib.h>
int _tmain(int argc, _TCHAR* argv[])
{
int A[] = {1,6,2,11,8,19,123,5,22,10};
heap_sort(A,10);
for(int i = 0; i<10; i++)
printf("%d ",A[i]);
system("pause");
return 0;
}