排序算法之堆排序（Heapsort）解析

一.堆排序的优缺点（pros and cons）

（还是简单的说说这个，毕竟没有必要浪费时间去理解一个糟糕的的算法）

优点：

堆排序的效率与快排、归并相同，都达到了基于比较的排序算法效率的峰值（时间复杂度为O(nlogn)）

除了高效之外，最大的亮点就是只需要O(1)的辅助空间了，既最高效率又最节省空间，只此一家了

堆排序效率相对稳定，不像快排在最坏情况下时间复杂度会变成O(n^2)），所以无论待排序序列是否有序，堆排序的效率都是O(nlogn)不变（注意这里的稳定特指平均时间复杂度=最坏时间复杂度，不是那个“稳定”，因为堆排序本身是不稳定的）

缺点：（从上面看，堆排序几乎是完美的，那么为什么最常用的内部排序算法是快排而不是堆排序呢？）

最大的也是唯一的缺点就是——堆的维护问题，实际场景中的数据是频繁发生变动的，而对于待排序序列的每次更新（增，删，改），我们都要重新做一遍堆的维护，以保证其特性，这在大多数情况下都是没有必要的。（所以快排成为了实际应用中的老大，而堆排序只能在算法书里面顶着光环，当然这么说有些过分了，当数据更新不很频繁的时候，当然堆排序更好些...）

二.内部原理

首先要知道堆排序的步骤：

构造初始堆，即根据待排序序列构造第一个大根堆或者小根堆（大根堆小根堆是什么？这个不解释了，稻草垛知道吧..）

首尾交换，断尾重构，即对断尾后剩余部分重新构造大（小）根堆

重复第二步，直到首尾重叠，排序完成

按小根堆排序结果是降序（或者说是非升序，不要在意这种细节..），按大根堆排序的结果是升序

上面这句话乍看好像不对（小根堆中最小元素在堆顶，数组组堆顶元素就是a[0]，怎么会是降序？），不过不用质疑这句话的正确性，看了下面这几幅图就明白了：

假设待排序序列是a[] = {7, 1, 6, 5, 3, 2, 4}，并且按大根堆方式完成排序

第一步（构造初始堆）：



{7, 5, 6, 1, 3, 2, 4}已经满足了大根堆，第一步完成

第二步（首尾交换，断尾重构）：



第三步（重复第二步，直至所有尾巴都断下来）：

无图，眼睛画瞎了，mspaint实在不好用。。到第二步应该差不多了吧，剩下的用笔也就画出来了。。

其实核心就是“断尾”，但可悲的是所有的资料上都没有明确说出来，可是，还有比“断尾”更贴切的描述吗？

三.实现细节

原理介绍中给出的图基本上也说清楚了实现细节，所以这里只关注代码实现

首先是自己写出来的大根堆方式实现：

#include<stdio.h>

//构造大根堆（让a[m]到a
满足大根堆）
void HeapAdjust(int a[], int m, int n){
int temp;
int max;
int lc;//左孩子
int rc;//右孩子

while(1){
//获取a[m]的左右孩子
lc = 2 * m + 1;
rc = 2 * m + 2;
//比较a[m]的左右孩子，max记录较大者的下标
if(lc >= n){
break;//不存在左孩子则跳出
}
if(rc >= n){
max = lc;//不存在右孩子则最大孩子为左孩子
}
else{
max = a[lc] > a[rc] ? lc : rc;//左右孩子都存在则找出最大孩子的下标
}
//判断并调整（交换）
if(a[m] >= a[max]){//父亲比左右孩子都大，不需要调整，直接跳出
break;
}
else{//否则把小父亲往下换
temp = a[m];
a[m] = a[max];
a[max] = temp;
//准备下一次循环，注意力移动到孩子身上，因为交换之后以孩子为根的子树可能不满足大根堆
m = max;
}
}
}

void HeapSort(int a[], int n){
int i,j;
int temp;

//自下而上构造小根堆（初始堆）
for(i = n / 2 - 1;i >= 0;i--){//a[n/2 - 1]恰好是最后一个非叶子节点（叶子节点已经满足小根堆，只需要调整所有的非叶子节点），一点小小的优化
HeapAdjust(a, i, n);
}

printf("初始堆: ");
for(i = 0;i < n;i++){
printf("%d ", a[i]);
}
printf("\n");

for(i = n - 1;i > 0;i--){
//首尾交换，断掉尾巴
temp = a[i];
a[i] = a[0];
a[0] = temp;
//断尾后的部分重新调整
HeapAdjust(a, 0, i);

/*
printf("第%d次（i - 1 = %d）: ", n - i, i - 1);
for(j = 0;j < n;j++){
printf("%d ", a[j]);
}
printf("\n");
*/
}
}

main(){
//int a[] = {5, 6, 3, 4, 1, 2, 7};
//int a[] = {1, 2, 3, 4, 5, 6, 7};
//int a[] = {7, 6, 5, 4, 3, 2, 1};
int a[] = {7, 1, 6, 5, 3, 2, 4};
int m, n;
int i;

m = 0;
n = sizeof(a) / sizeof(int);
//HeapAdjust(a, m, n);
HeapSort(a, n);
printf("结果: ");
for(i = 0;i < n;i++){
printf("%d ", a[i]);
}
printf("\n");
}

P.S.代码中注释极其详尽，因为是完全一步一步自己想着写出来的，应该不难理解。看代码说话，在此多说无益。

接下来给出书本上的大根堆方式实现：

#include<stdio.h>

void HeapAdjust(int a[], int m, int n){
int i;
int t = a[m];

for(i = 2 * m + 1;i <= n;i = 2 * i + 1){
if(i < n && a[i + 1] > a[i])++i;
if(t >= a[i])break;
//把空缺位置往下放
a[m] = a[i];
m = i;
}
a[m] = t;//只做一次交换，步骤上的优化
}

void HeapSort(int a[], int n){
int i;
int t;

//自下而上构造大根堆
for(i = n / 2 - 1;i >= 0;--i){
HeapAdjust(a, i, n - 1);
}

printf("初始堆: ");
for(i = 0;i < n;i++){
printf("%d ", a[i]);
}
printf("\n");

for(i = n - 1;i > 0;i--){
//首尾交换，断掉尾巴
t = a[i];
a[i] = a[0];
a[0] = t;
//对断尾后的部分重新建堆
HeapAdjust(a, 0, i - 1);
}
}

main(){
//int a[] = {5, 6, 3, 4, 1, 2, 7};
//int a[] = {1, 2, 3, 4, 5, 6, 7};
//int a[] = {7, 6, 5, 4, 3, 2, 1};
int a[] = {7, 1, 6, 5, 3, 2, 4};
int m, n;
int i;

m = 0;
n = sizeof(a) / sizeof(int);
//HeapAdjust(a, m, n);
HeapSort(a, n);
printf("结果: ");
for(i = 0;i < n;i++){
printf("%d ", a[i]);
}
printf("\n");
}

P.S.书本上的代码短了不少，不仅仅是篇幅上的优化，也有实实在在的步骤上的优化，细微差别也在注释中说明了。但这种程度的优化却使得代码的可读性大大降低，所以一次次拿起算法书，又一次次放下。。（实际应用中我们可以对书本上的代码做形式上的优化，在保持其高效性的同时尽可能的提升其可读性。。）

最后是在研究过书本上的算法之后，结合其优化措施，写出的小根堆方式实现（网上的资料多是大根堆方式的，其实原理都一样，这里只是为了避免枯燥无趣。。）：

#include<stdio.h>

//构造小根堆（让a[m]到a
满足小根堆）
void HeapAdjust(int a[], int m, int n){
int i;
int t = a[m];
int temp;

for(i = 2 * m + 1;i <= n;i = 2 * i + 1){
//a[m]的左右孩子比较，i记录较小者的下标
if(i < n && a[i + 1] < a[i]){
i = i + 1;
}
if(t <= a[i]){
break;
}
else{//把空缺位置往下换
//把较小者换上去
temp = a[m];
a[m] = a[i];
a[i] = temp;
//准备下一次循环
m = i;
}
}
}

void HeapSort(int a[], int n){
int i, j;
int temp;

//自下而上构造小根堆（初始堆）
for(i = n / 2 - 1;i >= 0;i--){//a[n/2 - 1]恰好是最后一个非叶子节点（叶子节点已经满足小根堆，只需要调整所有的非叶子节点），一点小小的优化
HeapAdjust(a, i, n);
}

printf("初始堆: ");
for(i = 0;i < n;i++){
printf("%d ", a[i]);
}
printf("\n");

//把每个元素都调整到应该去的位置
for(i = n - 1; i > 0;i--){
//首尾交换
temp = a[i];
a[i] = a[0];
a[0] = temp;
//断尾后剩余部分重新调整
HeapAdjust(a, 0, i - 1);
}
}

main(){
//int a[] = {7, 6, 5, 4, 3, 2, 1};
//int a[] = {1, 5, 6, 4, 3, 2, 7};
int a[] = {1, 2, 3, 4, 5, 6, 7};
int m, n;
int i;

m = 0;
n = sizeof(a) / sizeof(int);
//HeapAdjust(a, m, n);
HeapSort(a, n);
printf("结果: ");
for(i = 0;i < n;i++){
printf("%d ", a[i]);
}
printf("\n");
}

P.S.注释依然详尽，看代码，不废话

四.总结

堆排序的步骤就几个字而已：建堆 -> 首尾交换，断尾重构 -> 重复第二步，直到断掉所有尾巴

还有比这更清晰更明了的描述吗？

到现在我们已经掌握了几个有用的排序算法了：

快速排序、归并排序、堆排序

那么实际应用中要如何选择呢？有这些选择标准：

若n较小，采用插入排序和简单选择排序。由于直接插入排序所需的记录移动操作比简单选择排序多，所以当记录本身信息量比较大时，用简单选择排序更好。

若待排序序列基本有序，可以采用直接插入排序或者冒泡排序

若n较大，应该采用时间复杂度最低的算法，比如快排，堆排或者归并

细分的话，当数据随机分布时，快排最佳（这与快排的硬件优化有关，在之前的博文中有提到过）

堆排只需要一个辅助空间，而且不会出现快排的最坏情况

快排和堆排都是不稳定的，如果要求稳定的话可以采用归并，还可以把直接插入排序和归并结合起来，先用直接插入获得有序碎片，再归并，这样得到的结果也是稳定的，因为直接插入是稳定的

说明：在理解“断尾”的过程中参考了前辈的博文，特此感谢