堆排序

原出处：http://blog.csdn.net/zhangxiangdavaid/article/details/30069623

 

堆排序(Heap Sort)：使用堆这种数据结构来实现排序。

先看下堆的定义：

最小堆(Min-Heap)是关键码序列{k0,k1,…,kn-1}，它具有如下特性：

ki<=k2i+1，

ki<=k2i+2(i=0,1,…)

简单讲：孩子的关键码值大于双亲的。

同理可得，最大堆(Max-Heap)的定义：

ki>=k2i+1，

ki>=k2i+2(i=0,1,…)

同样的：对于最大堆，双亲的关键码值大于两个孩子的(如果有孩子)。

堆的特点：

1. 堆是一种树形结构，而且是一种特殊的完全二叉树。
2. 其特殊性表现在：它是局部有序的，其有序性只体现在双亲节点和孩子节点的关系上(树的每一层的大小关系也是可以体现的)。兄弟节点无必然联系。
3. 最小堆也被称为小顶堆(根节点是最小的)，最大堆也被称为大顶堆(根节点是最大的)。我们常利用最小堆实现从小到大的排序，最大堆实现从大到小的排序。

最小堆和最大堆的两个示例图：

要想实现排序，第一个问题：如何建堆？(以最小堆为例，最大堆同理)

建堆：从最后一个内部节点开始，不断地向下调整，直到根节点。

画个流程图，看得更明白：矩形框表示要调整的位置

仔细看上面的流程图，相信你一定可以清楚明白整个调整过程。

建堆代码：我们使用顺序结构存储堆(可不要以为树形结构一定得使用链表来实现)，向下调整(heapSiftDown())的方法是关键，建堆的代码如下：

[cpp] view plaincopyprint?

1. void heapSiftDown(int a[], int n, int pos)   //从pos位置向下调整  
2. {  
3.     int i = pos;  
4.     int j = 2 * i + 1;   //j为i的左孩子  
5.     while (j < n)  
6.     {  
7.         if (j + 1 < n && a[j + 1]<a[j])   //如果右孩子存在，并且右孩子<左孩子  
8.             j++;  
9.         if(a[i] < a[j])   //已满足堆序，不需调整  
10.             break;   //为什么不是continue?因为子树已经排好堆序，结合流程图想想？  
11.         swap(a[i], a[j]);   //交换元素  
12.         i = j;  
13.         j = 2 * i + 1;  
14.     }  
15. }  
16. void createHeap(int a[], int n)   //建堆  
17. {  
18.     if (a && n > 1)  
19.     {  
20.         for (int i = (n - 2) / 2; i >= 0; i--)  //(n-2)/2是最后一个内部节点的下标  
21.             heapSiftDown(a, n, i);  
22.     }  
23. }  

void heapSiftDown(int a[], int n, int pos)   //从pos位置向下调整{int i = pos;int j = 2 * i + 1;   //j为i的左孩子while (j < n){if (j + 1 < n && a[j + 1]<a[j])   //如果右孩子存在，并且右孩子<左孩子j++;if(a[i] < a[j])   //已满足堆序，不需调整break;   //为什么不是continue?因为子树已经排好堆序，结合流程图想想？swap(a[i], a[j]);   //交换元素i = j;j = 2 * i + 1;}}void createHeap(int a[], int n)   //建堆{if (a && n > 1){for (int i = (n - 2) / 2; i >= 0; i--)  //(n-2)/2是最后一个内部节点的下标heapSiftDown(a, n, i);}}

建好堆之后，如何实现堆排序呢？排序之前，我们先看有关堆的两个操作：插入和删除。理解了这两个操作，排序就自然清楚了。

堆的插入：插入时总是把新节点插入到堆的最后，并从插入位置向上调整，直到根节点或在此之前已满足堆序。
举个例子解释下这个过程：

红色的3是新添的节点。

注意：向上调整的时候，只关注插入位置到根节点的路径，其它路径上的节点是不用调整的。理由很简单：它们已是堆序。这一点可要想清楚了！

向上调整的代码如下：

[cpp] view plaincopyprint?

1. const int MAX=20;  
2. void heapSiftUp(int a[], int n)   //向上调整   
3. {  
4.     int i,j;  
5.     j = n-1;  
6.     i = (i-1)/2;   //i为j的父节点   
7.     while(i>=0)  
8.     {  
9.         if(a[j] >= a[i])  
10.         break;  
11.         swap(a[i], a[j]);  
12.         j = i;  
13.         i = (j-1)/2;  //更精确的写法： i=j%2?(j-1)/2:(j-2)/2;  
14.     }   
15. }  
16. void addToHeap(int a[], int n, int data)  
17. {  
18.     /* 
19.     前提：数组a已排好堆序且数组还有多余位置存放新节点  
20.     */  
21.     if(n+1>MAX)  
22.     {  
23.         printf("数组已满！无法插入\n");  
24.         return;  
25.     }  
26.     n++;  
27.     a[n-1]=data;  //把新节点加到最后   
28.     heapSiftUp(a, n);     
29. }  

const int MAX=20;void heapSiftUp(int a[], int n)   //向上调整 {int i,j;j = n-1;i = (i-1)/2;   //i为j的父节点while(i>=0){if(a[j] >= a[i])break;swap(a[i], a[j]);j = i;i = (j-1)/2;  //更精确的写法： i=j%2?(j-1)/2:(j-2)/2;} }void addToHeap(int a[], int n, int data){/*前提：数组a已排好堆序且数组还有多余位置存放新节点 */if(n+1>MAX){printf("数组已满！无法插入\n");return;}n++;a[n-1]=data;  //把新节点加到最后heapSiftUp(a, n);}

堆的删除：删除操作总是在堆顶进行(也有的说，可以在任意位置删除，但做法一样)，我们把最后一个节点填入待删除位置。然后从该位置向下调整。
同样给个示例图：

结合上面以给出的向下调整代码，则很好得到堆删除的代码，为了通用性，我们给出指定位置删除的代码：

[cpp] view plaincopyprint?

1. void deleteAt(int a[], int &n, int pos)  //删除pos位置的节点  
2. {  
3.     if(pos >= n)  
4.     {  
5.         printf("删除的位置不对！\n");  
6.         return;  
7.     }  
8.     a[pos] = a[n-1];  //把最后一个节点填到待删除位置    
9.     n--;  
10.     heapSiftDown(a, n, pos);   //向下调整    
11. }   

void deleteAt(int a[], int &n, int pos)  //删除pos位置的节点{if(pos >= n){printf("删除的位置不对！\n");return;}a[pos] = a[n-1];  //把最后一个节点填到待删除位置 n--;heapSiftDown(a, n, pos);   //向下调整 } 

特别地，删除堆顶就是 deleteAt(a, n, 0);

有了上面的铺垫，堆排序就呼之欲出了。

堆排序步骤：

1. 先建好堆。
2. 不断地删除堆顶即可(删除前记得打印堆顶元素)，直到只剩下一个元素。

似乎堆的插入操作没有用到。其实，当有新的元素参与排序时，就用到了。

下面看一个完整的堆排序代码：

[cpp] view plaincopyprint?

1. #include<iostream>   
2. using namespace std;  
3. void heapSiftDown(int a[], int n, int pos)   //从pos位置向下调整  
4. {  
5.     int i = pos;  
6.     int j = 2 * i + 1;   //j为i的左孩子  
7.     while (j<n)  
8.     {  
9.         if (j + 1 < n && a[j + 1]<a[j])   //如果右孩子存在，并且右孩子<左孩子  
10.             j++;  
11.         if(a[i] < a[j])   //已满足堆序，不需调整  
12.             break;   //为什么不是continue?因为子树已经排好堆序  
13.         swap(a[i], a[j]);   //交换元素  
14.         i = j;  
15.         j = 2 * i + 1;  
16.     }  
17. }  
18. void createHeap(int a[], int n)   //建堆  
19. {  
20.     if (a && n > 1)  
21.     {  
22.         for (int i = (n - 2) / 2; i >= 0; i--)  
23.             heapSiftDown(a, n, i);  
24.     }  
25. }  
26. void deleteAt(int a[], int &n, int pos)  //删除pos位置的节点  
27. {  
28.     if(pos >= n)  
29.     {  
30.         printf("删除的位置不对！\n");  
31.         return;  
32.     }  
33.     a[pos] = a[n-1];  //把最后一个节点填到待删除位置   
34.     n--;  
35.     heapSiftDown(a, n, pos);   //向下调整   
36. }   
37. void HeapSort(int a[], int n)    //堆排序  
38. {  
39.     if (a && n > 1)  
40.     {  
41.         createHeap(a, n);  
42.         while (n > 1)  
43.         {  
44.             printf("%4d", a[0]);  
45.             deleteAt(a, n, 0);  
46.         }  
47.         printf("%4d\n", a[0]);  
48.     }  
49. }  
50. int main()  
51. {  
52.     printf("堆排序演练\n");  
53.     printf("原序列\n");  
54.     const int N = 12;  
55.     int *a = new int[N];  
56.     srand((unsigned)time(NULL));  
57.     for (int i = 0; i < N; i++)  
58.     {  
59.         a[i] = rand() % 100;  
60.         printf("%4d", a[i]);  
61.     }  
62.     printf("\n");  
63.     printf("经过堆排序\n");  
64.     HeapSort(a, N);  
65.     delete[]a;  
66.     system("pause");  
67.     return 0;  
68. }