《数据结构与算法》（二十三）- 排序算法：堆排序

原文地址：https://program-park.github.io/2021/11/24/algorithm_23/

前言

部分内容摘自程杰的《大话数据结构》

---

1. 堆排序

  我们前面讲到简单选择排序，它在待排序的n个记录中选择一个最小的记录需要比较n-1次。本来这也可以理解，查找第一个数据需要比较这么多次是正常的，否.则如何知道它是最小的记录。
  可惜的是，这样的操作并没有把每一趟的 比较结果保存下来，在后一趟的比较中，有许多比较在前一趟已经做过了，但由于前一趟排序时未保存这些比较结果，所以后一趟排序时又重复执行了这些比较操作，因而记录的比较次数较多。
  如果可以做到每次在选择到最小记录的同时，并根据比较结果对其他记录做出相应的调整，那样排序的总体效率就会非常高了。而堆排序（Heap Sort），就是对简单选择排序进行的一种改进，这种改进的效果是非常明显的。堆排序算法是 Floyd 和 Williams 在 1964 年共同发明的，同时，他们发明了 “堆” 这样的数据结构。
  “堆” 结构相当于把数字符号堆成一个塔型的结构。当然，这绝不是简单的堆砌。大家看下图所示，能够找到什么规律吗？

  很明显，我们可以发现它们都是二叉树，如果观察仔细些，还能看出它们都是完全二叉树。左图中根结点是所有元素中最大的，右图的根结点是所有元素中最小的。再细看看，发现左图每个结点都比它的左右孩子要大，右图每个结点都比它的左右孩子要小。这就是我们要讲的堆结构。
  堆是具有下列性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆（例如上图左图所示）；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆（例如上图右图所示）。
  这里需要注意从堆的定义可知，根结点一定是堆中所有结点最大（小）者。较大（小）的结点靠近根结点（但也不绝对，比如右图小顶堆中 60、40 均小于 70，但它们并没有 70 靠近根结点）。
  如果按照层序遍历的方式给结点从 1 开始编号，则结点之间满足如下关系：

  这里为什么i要小于等于 $\lfloor n/2\rfloor$ 呢？相信大家可能都忘记了前面讲的二叉树的性质 5，其实忘记也不奇怪，这个性质在我们讲完之后，就再也没有提到过它。可以说，这个性质仿佛就是在为堆准备的。性质 5 的第一条就说一棵完全二叉树，如果i=1，则结点i是二叉树的根，无双亲；如果i>1，则其双亲是结点 $\lfloor n/2\rfloor$。那么对于有n个结点的二叉树而言，它的i值自然就是小于等于 $\lfloor n/2\rfloor$ 了。性质 5 的第二、三条，也是在说明下标i与2i和2i+1的双亲子女关系。
  如果将上图的大顶堆和小顶堆用层序遍历存入数组，则一定满足上面的关系表达，如下图所示。

  我们现在讲这个堆结构，其目的就是为了堆排序用的。

1.1 堆排序算法

  堆排序（Heap Sort）就是利用堆（假设利用大顶堆）进行排序的方法。它的基本思想是，将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根结点。将它移走（其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值），然后将剩余的n-1个序列重新构造成一个堆， 这样就会得到n个元素中的次小值。如此反复执行，便能得到一个有序序列了。
  例如下图所示，图①是一个大顶堆，90 为最大值，将 90 与 20（末尾元素）互换，如图②所示，此时 90 就成了整个堆序列的最后一个元素， 将 20 经过调整，使得除 90 以外的结点继续满足大顶堆定义（所有结点都大于等于其子孩子），见图③，然后再考虑将 30 与 80 互换······


  相信大家有些明白堆排序的基本思想了，不过要实现它还需要解决两个问题：

1. 如何由一个无序序列构建成一个堆？
2. 如果在输出堆项元素后，调整剩余元素成为一个新的堆？

  要解释清楚它们，让我们来看代码。

/* 对顺序表L进行堆排序 */
void HeapSort(SqList *L)
{
	int i;
	for (i=L->length/2;i>0;i--)	/* 把L中的r构建成一个大顶堆 */
		HeapAdjust(L,i,L->1ength) ;
		
	for (i=L->length;i>1;i-- )
	{
		swap(L,1,i);	/* 将堆顶记录和当前未经排序子序列的最后一个记录交换 */
		HeapAdjust(L,1,i-1);	/* 将L->r[1..i-1]重新调整为大顶堆 */
	}
}

  从代码中也可以看出，整个排序过程分为两个for循环。第一个循环要完成的就是将现在的待排序序列构建成一个大顶堆。第二个循环要完成的就是逐步将每个最大值的根结点与末尾元素交换，并且再调整其成为大顶堆。
  假设我们要排序的序列是 {50,10,90,30,70,40,80,60,20}，那么L.length=9，第一个for循环，代码第 4 行，i是从 $\lfloor 9/2\rfloor =4$ 开始，4→3→2→1 的变量变化。为什么不是从 1 到 9 或者从 9 到 1，而是从 4 到 1 呢？其实我们看了下图就明白了，它们都有什么规律？它们都是有孩子的结点。注意灰色结点的下标编号就是 1、2、3、4。

  我们所谓的将待排序的序列构建成为一个大顶堆，其实就是从下往上、从右到左，将每个非终端结点（非叶结点）当作根结点，将其和其子树调整成大顶堆。i的 4→3-→2→1 的变量变化，其实也就是 30，90，10、50 的结点调整过程。
  既然已经弄清楚i的变化是在调整哪些元素了，现在我们来看关键的 HeapAdjust（堆调整）函数是如何实现的。

/* 已知L->r[s..m]中记录的关键字除L->r[s]之外均满足堆的定义中 */
/* 本函数调整L->r[s]的关键字，使L->r[s..m]成为一个大顶堆 */
void HeapAdjust(SqList *L,int s,int m)
{
	int temp,j;
	temp=L->r[s];
	for(j=2*s;j<=m;j*=2)	/* 沿关键宇较大的孩子结点向下筛选 */
	{
		if(j<m && L->r[f]<L->r[j+1])
			++j;	/* 为关键字中较大的记录的下标 */
		if (temp>=L->r[j] )
			break;	/* rc应插入在位置s上 */
		L->r[s]=L->r[j];
		s=j;
	}
	L->r[s]=temp;	/* 插入 */
}

1. 函数被第一次调用时，s=4，m=9，传入的SqList参数的值为length=9，r[10]={0,50,10,90,30,70,40,80,60,20}。
2. 第 4 行，将L.r[s]=L.r[4]=30赋值给temp，如下图所示。
   
3. 第 5~13 行，循环遍历其结点的孩子。这里j变量为什么是从2*s开始呢？又为什么是j*=2递增呢？原因还是二叉树的性质 5，因为我们这棵是完全二杈树，当前结点序号是s，其左孩子的序号一定是2s，右孩子的序号一定是2s+1，它们的孩子当然也是以 2 的位数序号增加，因此j变量才是这样循环。
4. 第 7~8 行，此时j=2*4=8，j<m说明它不是最后一个结点，如果L.r[j]<L.r[j+1]，则说明左孩子小于右孩子。我们的目的是要找到较大值，当然需要让j+1以便变成指向右孩子的下标。当前 30 的左右孩子是 60 和 20，并不满足此条件，因此j还是 8。
5. 第 9~10 行，temp=30，L.r[j]=60，并不满足条件。
6. 第 11~12 行，将 60 赋值给L.r[4]，并令s=j=8。也就是说，当前算出，以 30 为根结点的子二叉树，当前最大值是 60，在第 8 的位置。注意此时L.r[4]和L.r[8]的值均为 60。
7. 再循环因为j=2*j=16，m=9，j>m，因此跳出循环。
8. 第 14 行，将temp=30赋值给L.r[s]=L.r[8]，完成 30 与 60 的交换工作。如下图所示。本次函数调用完成。
   
9. 再次调用HeapAdjust，此时s=3，m=9。 第 4 行，temp=L.r[3]=90，第 7~8 行，由于40<80得到j+1=2*s+1=7。9~10 行，由于90>80，因此退出循环，最终本次调用，整个序列未发什么改变。
10. 再次调用HeapAdjust，此时s=2，m=9。第 4 行，temp=L.r[2]=10，第 7~8 行，60<70，使得j=5。最终本次调用使得 10 与 70 进行了互换，如下图所示。
    
    
11. 再次调用HeapAdjust，此时s=1，m=9。 第 4 行，temp=L.r[1]=50，第 7~8 行，70<90，使得j=3。第 11~12 行，L.r[1]被赋值了 90，并且s=3，再循环，由于2j=6并未大于m，因此再次执行循环体，使得L.r[3]被赋值了 80，完成循环后，L.r[7]被赋值为 50，最终本次调用使得 50、90、 80 进行了轮换，如下图所示。
    

  到此为止，我们构建大顶堆的过程算是完成了，也就是HeapSort函数的第 4~5 行循环执行完毕。或许是有点复杂，如果不明白，多试着模拟计算机执行的方式走几遍，应该就可以理解其原理。
  接下来HeapSort函数的第 6~11 行就是正式的排序过程，由于有了前面的充分准备，其实这个排序就比较轻松了。下面是这部分代码。

for (i=L->length;i>1;i-- )
{
	swap(L,1,i);	/* 将堆顶记录和当前未经排序子序列的最后一个记录交换 */
	HeapAdjust(L,1,i-1);	/* 将L->r[1..i-1]重新调整为大顶堆 */
}

1. 当i=9时，第 8 行，交换 20 与 90，第 9 行，将当前的根结点 20 进行大顶堆的调整，调整过程和刚才流程一样，找到它左右子结点的较大值，互换，再找到其子结点的较大值互换。此时序列变为 {80,70,50,60,10,40,20,30,90}，如下图所示。
   
2. 当i=8时，交换 30 与 80，并将 30 与 70 交换，再与 60 交换，此时序列变为 {70,60,50,30,10,40,20,80,90}，如下图所示。
   
3. 后面的变化完全类似，不解释，只看下图。
   
     最终就得到一一个完全有序的序列了。

1.2 堆排序复杂度分析

  堆排序的效率到底有多高呢?我们来分析- - 下。
  它的运行时间主要是消耗在初始构建堆和在重建堆时的反复筛选上。
  在构建堆的过程中，因为我们是完全二叉树从最下层最右边的非终端结点开始构建，将它与其孩子进行比较和若有必要的互换，对于每个非终端结点来说，其实最多进行两次比较和互换操作，因此整个构建堆的时间复杂度为 $O(n)$。
  在正式排序时，第i次取堆顶记录重建堆需要用 $O(logi)$ 的时间（完全二叉树的某个结点到根结点的距离为 $\lfloor lo{g}_{2}i\rfloor +1$），并且需要取n-1次堆顶记录，因此，重建堆的时间复杂度为 $O(nlogn)$。
  所以总体来说，堆排序的时间复杂度为 $O(nlogn)$。 由于堆排序对原始记录的排序状态并不敏感，因此它无论是最好、最坏和平均时间复杂度均为 $O(nlogn)$。 这在性能上显然要远远好过于冒泡、简单选择、直接插入的 $O(n^2)$ 的时间复杂度了。
  空间复杂度上，它只有一个用来交换的暂存单元，也非常的不错。不过由于记录的比较与交换是跳跃式进行，因此堆排序也是一种不稳定的排序方法。
  另外，由于初始构建堆所需的比较次数较多，因此，它并不适合待排序序列个数较少的情况。

2. 总结

  排序算法的总结在后面讲完归并排序及快速排序后再写，也就是快速排序博客的最后。