第二部分 排序和顺序统计量 第 6 章 堆排序

排序算法
　　插入排序最坏情况下可以再$θ(n^2)$时间内将 n 个数排好序。但是，由于其内层循环紧凑，对于小规模输入，是一张非常快的原址排序（如果输入数组中仅有常数个元素需要在排序过程中存储在数组之外，则称排序算法是原址的）。归并排序不是原址的。
　　第 6 章介绍的堆排序，是一种$θ(n \lg n)$时间的原址排序算法。
　　第 7 章介绍快速排序，也是一种原址排序，但最坏情况时间为$θ(n^2)$，然而期望运行时间为$θ(n \lg n)$，而且在实际应用中，通常比堆排序快。与插入排序类似，快速排序的代码也很紧凑，因此运行时间中隐含的常数系数很小。快速排序是排序大数组的最常用算法。

　　顺序统计量
　　一个n个数的集合的第 i 个顺序统计量就是集合中第 i 个小的数。当然，我们可以通过将输入集合排序，取输出的第 i 个元素来选择第 i 个顺序统计量。当不知道输入数据的分布时，这种方法的运行时间为Ω（nlgn），即第 8 章所证明的比较排序算法的下界。
　　在第 9 章，我们展示了即使输入数据是任意实数，也可以在O(n)时间内找到第 i 个小的元素。我们提出了一种随机算法，其伪代码非常紧凑，它的最欢情况运行时间为$θ(n^2)$，但期望运行时间为O（n）。
　　

第 6 章 堆排序

　　堆排序的时间复杂度是$θ(n\lg n)$,但不同于归并排序的是，堆排序同样具有空间原址性：任何时候都只需要常数个额外的元素空间存储临时数据。因此，堆排序是集合了归并排序和插入排序两种排序算法的优点。
　　堆排序引入了另一种算法设计技巧：使用一种我们称为“堆”的数据结构来进行信息管理。堆不仅用在堆排序中，而且它也可以构造一种有效的优先队列。

6.1 堆

　　（二叉）堆是一个数组，它可以被看成一个近似的完全二叉树。树上的每一个节点对应数组中的一个元素。除了最底层外，该数是完全充满的，而且是从左向右填充。表示堆的数组A包括两个属性：A.length（通常）给出数组元素的个数，A.heap-size表示有多少个堆元素存储在该数组中。这里：0 <= A.heap-size <= A.length。
　　
　　图6-1 以二叉树和数组形式展现的一个最大堆。每个节点圆圈内部的数字是它所存储的数据。节点上方的数字是它在数组中相应的下标。数组上方和下方的连线显示的是父子关系：父节点总是在它的孩子节点的左边。该数的高度为 3，下标为4（值为8）的节点的高度为1.
　　
数的根节点是A[1]，给定一个节点的下标i，可以很容易得到它的父节点、左孩子和右孩子的小标：

PARENT(i)
    return i/2
LEFT(i)
    return 2i
RIGHT(i)
    return 2i+1

　　二叉树可以分为两种形式：最大堆和最小堆。在这两个堆中，节点的值都要满足堆的性质，但一些细节定义有所差异。在最大堆中，最大堆性质是指除了满足根以外的所有节点 i 都要满足：
　　A[PARENT(i)]>=A[i]
也就是说，某个节点的值至多与其父节点一样大。因此，堆中的最大元素存放在根节点中。最小堆的组织方式正好相反：最小堆性质是指除了根以外的所有节点 i 都有
　　A[PARENT(i)]>=A[i]
最小堆的最小元素存放在根节点中。
　　在堆排序算法中，我们使用的是最大堆。最小堆通常用于构造优先队列。
　　我们定义一个堆中的节点的高度就为该节点到叶节点最长简单路径上边的数目；进而，我们可以把堆的高度定义为根节点的高度。既然一个包含 n 个元素的队可以看做一颗完全二叉树，那么该堆的高度是θ（lg n）。我们会发现，堆结构上的一些基本操作的运行时间至多与数的高度成正比，即时间复杂度为O(lgn)。在本章剩余部分将介绍一些基本过程：
　　

• MAX-HEAPIFY过程：其时间复杂度为O(lgn)，它是维护最大堆性质的关键。
• BUILD-MAX-HEAP过程：具有线性时间复杂度，功能是从无序的输入数据数组中构造一个最大堆。
• HEAPSORT：其时间复杂度为O(nlgn)，功能是一个数组进行原址排序。
• MAX-HEAP-INSERT、HEAP-EXTRACT-MAX、HEAP-INCREASE-KEY和HEAP-MAXIMUM过程：时间复杂度为O(lgn)，功能是利用堆实现一个优先队列。

6.2 维护堆的性质

MAX-HEAPIFY是用于维护最大堆性质的重要过程，它的输入为一个数组A和一个下标 i。在调用MAX-HEAPIFY时，我们假定根节点为LEFT（i）和RIGHT（i）的二叉树都是最大堆，但这是A[i]有可能小于其孩子。MAX-HEAPIFY通过让A[i]的值逐级下降，从而使得下标 i 为根节点的子树重新遵循最大堆性质
MAX-HEAPIFY(A, i)

l = LEFT(i)
r = RIGHT(i)
if l <= A.heap-size and A[l] > A[i]
    largest = l
else largest = i
if r <= A.heap-size and A[r] > A[largest]
    largest = r
if largest != i
    exchangeA[i] with A[largest]
    MAX-HEAPY(A, largest)

我们用下面的递归式刻画MAX-HEAPIFY的运行时间：
T(n)<= T(2n/3) + θ（1）
根据主定理，上述的解为T(n)= O(lgn)。也就是说，对于一个树高为h的节点来说，MAX-HEAPIFY的时间复杂度为O(h)。

6.3 建堆

　　我们可以用自底向上的方法利用MAX-HEAPIFY把一个大小为n=A.length的数组A[1,…,n]转换为最大堆。过程BUILD-MAX-HEAP对数中的其他节点都调用一次MAX-HEAPIFY。
BUILD-MAX-HEAP（A）

A.heap-size = A.length
for i = A.length/2 downto 1
    MAX-HEAPIFY(A,i)

BUILD-MAX-HEAP的时间复杂度为O(n)。因此，我们可以在线性时间内，把一个无序数组构造称为一个最大堆。
　　类似地，我们也可以通过调用一个BUILD-MIN-HEAP构造一个最小堆。只需修改第 3 行的调用替换为MIN-HEAPIFY。

6.4 堆排序算法

　　初始时候，堆排序算法利用BUILD-MAX-HEAP将输入数组A[1..n]建成最大堆，其中n = A.length。因为数组中的最大元素总在根节点A[1]中，通过把它与A[n]进行交换，可以让该元素放到正确的位置。这是，去掉节点n，剩余的节点中，原来的根的节点仍然是最大堆，而新的跟节点可能会违背最大堆的性质。为了维护最大堆的性质，调用MAX-HEAPIFY（A, 1），从而在A[1..n-1]上构造一个新的最大堆。堆排序算法会不断重复这一过程，知道堆的大小从n-1降到2.
HEAPSORT（A)

BUILD-MAX-HEAP（A)
for i = A.length downto 2
    exchange A[1] with A[i]
    A.heap-size = A.heap-size - 1
    MAX-HEAPIFY(A, 1)

HEAPSORT过程的时间复杂度是O(nlgn)。

6.5 优先队列

　　和堆一样，优先队列也有两种形式：最大优先队列和最小优先队列。
　　优先队列是一种用来维护由一组元素构成的结合S的数据结构，其中的每一个元素都有一个相关的值，称为关键字。一个最大优先队列支持以下操作：
　　INSERT(S, x):把元素x插入集合S中。这一操作等价于S=SU{x}
　　MAXIMUM（S）：返回S中具有最大键字的元素。
　　EXTRACT-MAX(S):去掉并返回S中的具有最大键字的的元素。
　　INCREASE-KEY(S,x,k)：将元素x的关键字值增加到k，这里假设k的值不小于x的原关键字值。
　　最大优先队列的应用有很多，其中一个就是在共享计算机系统的作业调度。
　　现在我们来讨论如何实现最大优先队列的操作。过程HEAP-MAXIMUM可以在θ（1）时间内实现MAXIMUM操作。
HEAP-MAXIMUM（A）　　

return A[1]

过程HEAP-EXTRACT-MAX实现EXTRACT-MAX操作。
HEAP-EXTRACT-MAX（A）

if A.heap-size < 1
    errror "heap underflow"
max = A[1]
A[1] = A[A.heap-size]
A.heap-size = A.heap-size - 1
MAX-HEAPIFY(A, 1)
return max

HEPA-INCREASE-KEY能够实现INCREASE-KEY操作。
HEPA-INCRESE-KEY(A,i,key)

if key < A[i]
    error"new key is smaller than current key"
A[i] = key;
while i > 1 and A[PARENT(i)] < A[i]
    exchange A[i] with A[PARENT(i)]
    i = PARENT(i)

MAX-HEAP-INSERT能够实现INSERT操作。
MAX-HEAP-INSERT(A,key)

A.heap-size = A.heap-size + 1
A[A.heap-size] = -
HEAP-INCREASE-KEY（A, A.heap-size, key)

在包含n个元素的堆上，MAX-HEAP-INSERT的运行时为O(lgn)。
总之，在一个包含n个元素的堆中，所有优先队列的操作都可以在O(lgn)时间内完成。
练习：
1. 当用数组表示存储n个元素的堆时，叶节点的下标分别为⌊n/2⌋+1,⌊n/2⌋+2, … ,⌊n/2⌋+n.
2. 对于任一包含n个元素的堆中，至多有$⌈n/2^{h+1}⌉$个高度为h的节点。
3.