算法导论总结索引 | 第二部分第六章：堆排序

Asher Gu

已于 2024-06-26 10:56:08 修改

阅读量966

点赞数 20

分类专栏：算法导论文章标签：算法排序算法

于 2024-03-04 12:43:30 首次发布

本文链接：https://blog.csdn.net/AsherGu/article/details/136437339

版权

算法导论专栏收录该内容

24 篇文章 1 订阅

订阅专栏

本文详细介绍了排序算法如插入排序、归并排序、堆排序和快速排序，强调了它们的时间复杂度、原址性以及在构建最大堆和优先级队列中的应用。讨论了如何维护堆的性质以及堆排序的HEAPSORT过程。

摘要由CSDN通过智能技术生成

第二部分：排序和排序统计量（96）

1、每个记录包含一个关键字，就是排序问题中要重排的值。记录的剩余部分由卫星数据组成，通常与关键字是一同存取的
关注排序问题，通常假定输入只是由数组成

2、插入排序最坏情况下可以在Θ(n²)时间内将n个数排好序。对于小规模的输入，插入排序是一种非常快的原址排序（输入数组中仅有常数个元素需要在排序过程中存储在数组外）算法

归并排序有更好的渐近运行时间Θ(nlgn)，但它所使用的 MERGE过程并不是原址的

第六章介绍堆排序，是一种O(n lgn)时间的原址排序算法。堆还可以实现优先级队列

第七章介绍快速排序，是一种原址排序算法，最坏情况运行时间为Θ(n²)，它的期望运行时间为Θ(n lgn)，在实际应用中通常比堆排序快。与插入排序类似，快速排序的代码很紧凑，因此运行时间中隐含的常数系数很小。快速排序是排序大数组的最常用算法

3、插入排序、归并排序、堆排序及快速排序都是比较排序算法：通过对元素进行比较操作来确定输入数组的有序次序。第八章介绍了决策树模型，可用来研究比较排序算法的性能局限。使用决策树模型，可以证明任意比较排序算法排序n个元素的最坏情况运行时间的下界为Ω(n lgn)，证明堆排序和归并排序是渐近最优的比较排序算法

通过比较操作之外的方法来获得输入序列有序次序的信息，可能打破Ω(n lgn)的下界。计数排序假定输入元素的值均在集合{0, 1, … , k} 内，可以在Θ(k + n)的时间内将n个数排好序
基数排序扩展计数排序的适用范围。如果有n个整数要进行排序，每个整数有d位数字，并且每个数字可能取k个值，基数排序就可以在Θ(d(n + k))时间内完成排序工作。当d是常数且 k = O(n)时，基数排序的运行时间就是线性的
桶排序算法，需要了解输入数组中数据的概率分布。对于半开区间[0, 1) 内服从均匀分布的n个实数，桶排序的平均情况运行时间为O(n)

算法	最坏情况运行时间	平均情况/期望运行时间
插入排序	Θ(n²)	Θ(n²)
归并排序	Θ(n lgn)	Θ(n lgn)
堆排序	O(n lgn)	——
快速排序	Θ(n²)	Θ(n lgn) (期望)
计数排序	Θ(k + n)	Θ(k + n)
基数排序	Θ(d(n + k))	Θ(d(n + k))
桶排序	Θ(n²)	Θ(n) (评价情况)

与归并排序一样，堆排序的时间复杂度是 O(n lgn)。与插入排序相同，堆排序同样具有空间原址性

1、堆

1、（二叉）堆是一个数组，可以被看成一个近似的完全二叉树。除最底层外，该树是完全满的，从左向右填充
虽然 A[1…A.length] 可能都存有数据，但只有 A[1…A.heap-size] 中存放的是堆的有效元素，这里 0 <= A.heap-size <= A.length
它的父节点、左孩子和右孩子的下标：
堆父节点、左右孩子
连线是父子关系，父节点总在孩子节点的左边

通过将i的值左移一位，LEFT过程在一条指令内计算出2i。在RIGHT过程中通过将i的值左移一位并在低位加1，快速计算得到 2i + 1。PARENT过程中，可以通过把i的值右移1位计算得到⌊i/2⌋

2、二叉堆可以分为两种形式：最大堆和最小堆。在最大堆中，最大堆性质是指除了根以外的所有节点i都要满足

堆中的最大元素存放在根节点中

最小堆的组织方式正好相反：除了根以外的所有节点i都有
最小堆性质
3、在堆排序算法中，使用的最大堆；最小堆通常用于构造优先级队列

4、把堆的高度定义为根节点的高度。既然一个包含n个元素的队可以看做一棵完全二叉树，堆的高度是 Θ(lgn)。堆结构上的一些基本操作的运行时间至多与树的高度成正比（时间复杂度为 O(lgn)）

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

5、考虑下标为⌊n/2⌋+1的结点的左孩子下标

2、维护堆的性质（100）

1、MAX-HEAPIFY的输入为一个数组A 和下标i，调用的时候，假定根节点为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
		exchange A[i] with A[largest]
		MAX-HEAPIFY(A, largest)

从A[i]、A[LEFT(i)]和A[RIGHT(i)]中选出最大的，并将其下标存储在 largest中。如果A[i]是最大的，程序结束。最大元素是i的某个孩子节点，则交换A[i]和A[largest]的值，从而使i及其孩子都满足最大堆的性质。交换后，下标为largest的结点的值是原来的A[i]，以该节点为根的子树又可能违反最大堆的性质（因为值减小了），因此需要对该子树递归调用 MAX-HEAPIFY（过程如2中图印刷部分）

2、对于一棵以i为根节点、大小为n的子树，MAX-HEAPIFY的时间代价包括：调整A[i]、A[LEFT(i)] 和 A[RIGHT(i)] 的关系的时间代价Θ(1)，加上在一棵以i的一个孩子为根节点的子树上运行 MAX-HEAPIFY的时间代价
每个孩子的子树的大小至多为 2n/3（最坏情况发生在树的最底层恰好半满的时候）计算过程见下图红笔部分

MAX-HEAPIFY过程与递归计算
MAX-HEAPIFY过程与递归计算
递推公式和主定理计算过程
递推公式和主定理计算过程
MAX-HEAPIFY时间复杂度的计算
MAX-HEAPIFY时间复杂度的计算
3、用循环控制结构取代递归，重写MAX-HEAPIFY代码

MAX-HEAPIFY(A, i)
    while i ≤ A.heap-size/2 (循环部分，到叶子节点层（heap-size/2）为止)
        l = LEFT(i)
        r = RIGHT(i)
        if A[l] > A[i]
            largest = l
        else largest = i
        if A[r] > A[largest]
            largest = r
        if largest != i
            exchange A[i] with A[largest]
            i = largest （更新i）
        else break

4、

3、建堆

1、用自底向上的方法利用过程MAX-HEAPIFY把一个大小为 n = A.length 的数组 A[1…n]转化为最大堆
每个叶子节点都可以看成只包含一个元素的堆。过程 BUILD-MAX-HEAP 对树中的除叶节点之外的结点都调用一次 MAX-HEAPIFY
建堆过程
为了证明 BUILD-MAX-HEAP 的正确性，使用如下循环不变量：证明见 102
在第2-3行中每一次for循环开始，结点 i+1，i+2，…，n 都是一个最大堆的根节点

2、BUILD-MAX-HEAP 的时间复杂度：

公式 A.8 计算过程
在这里插入图片描述

构建堆的过程：

证明高度为h的堆最多包含 ⌈n/2^k+1⌉个高度为h的结点来自第六章堆排序答案
证明过程

4、堆排序算法

1、初始时候，堆排序算法利用BUILD-MAX-HEAP将输入数组 A[1…n] 建成最大堆。数组的最大元素总在根节点 A[1]中，通过把它与A[n] 进行互换，可以把元素放到正确的位置上。如果从堆中去掉结点n（减少A.heap-size来实现），剩余的节点中，原来根的孩子结点仍然是最大堆，而新换到根节点的可能会违背性质，调用 MAX-HEAPIFY(A, 1)，从而在 A[1…n-1]上构造一个新的最大堆。一直重复，直到堆的大小从 n-1降到2
算法描述
过程如下
过程1 过程2

2、时间复杂度：HEAPSORT过程的时间复杂度是 O(n lgn)，每次调用BUILD-MAX-HEAP的时间复杂度是O(n)，而n - 1次调用 MAX-HEAPIFY，每次的时间为 O(lgn)

3、证明HEAPSORT的正确性的循环不变量：在算法2-5行 for循环每次迭代开始时，子数组 A[1…i] 是一个包含了数组 A[1…n] 中第i小元素的最大堆，而子数组 A[i+1…n]包含了数组A[1…n]中已排序的 n-i 个最大元素

初始化：在第一次循环迭代之前，i=n，子数组A[1…n]是一个包含了数组A[1…n]中第n小元素的最大堆，而子数组A[n+1…n]包含了数组A[1…n]中已排序的0个最大元素。

保持：因为每次循环都把根结点从子数组A[1…i]中取出加入到子数组A[i+1…n]中，而且MAX-HEAPIFY维护了子数组A[1…i]是一个最大堆的性质，所以子数组A[1…i]是一个包含了数组A[1…n]中第i小元素的最大堆，而子数组A[i+1…n]包含了数组A[1…n]中已排序的n-i个最大元素。

终止：过程终止时，i=1，子数组A[1]包含了数组A[1…n]中的最小元素，而子数组A[2…n]包含了数组A[1…n]中已排序的n-1个最大元素，所以数组A[1…n]已经全部有序

4、对于一个按升序或降序排列的包含n个元素的有序数组A来说，HEAPSORT的时间复杂度都是O(nlgn)

倒序时，虽然在建堆时，MAX-HEAPIFY过程中不会进行再调用MAX-HEAPIFY，但是建堆过程中仍需要遍历数组只是不需要调整了，还是O(n)；在维护堆的时候还是需要n-1次交换并每次调整堆的操作把换上来的小根结点沉下去（O(lgn)），这里的代价是不变的，只要建堆建好了就有的代价，也是O(nlgn)

5、优先队列（105）

1、第七章介绍的快速排序性能优于堆排序

2、优先级队列有两种形式：最大优先队列和最小优先队列

3、优先队列是一种用来维护由一组元素构成的集合S的数据结构，其中的每一个元素都有一个相关的值，称为关键字。一个最大优先队列支持以下操作：
INSERT(S, x)：把元素x插入集合S中。这一操作等价于 S=S∪{x}
MAXIMUM(S)：返回S中具有最大关键字的元素
EXTRACT-MAX(S)：去掉并返回S中具有最大关键字的元素
INCREASE-KEY(S, x, k)：将元素x的关键字值增加到k，这里假设k的值不小于x的原关键字值

1）过程HEAP–MAXIMUM可以在Θ(1)时间内实现MAXIMUM操作

HEAP-MAXIMUM(A)
	return A[1]

2）过程 HEAP-EXTRACT-MAX 实现 EXTRACT-MAX 操作。它与 HEAPSORT 过程的 for循环体部分相似

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

HEAP-EXTRACT-MAX 的时间复杂度为 O(lgn)。时间复杂度为 O(lgn)的MAX-HEAPIFY之外，其他操作都是常数阶的

3）HEAP-INCREASE-KEY能够实现 INCREASE-KEY操作。需要将元素A[i]的关键字更新为新值，因为增大关键字A[i]可能违反最大堆的性质，采用了类似 INSERT-SORT中插入循环的方式，从当前结点到根结点的路径上，为新增的关键字寻找恰当的插入位置
在 HEAP-INCREASE-KEY的过程中，当前元素会不断地与其父结点进行比较，如果当前元素的关键字较大，则当前元素与其父结点进行交换。这一过程不断重复，直到当前元素的关键字小于其父结点时终止

HEAP-INCREASE-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)

HEAP-INCREASE-KEY的时间复杂度时 O(lgn)（因为关键字更新的结点到根结点的路径长度为O(lgn)）
HEAP-INCREASE-KEY操作过程
4）MAX-HEAP-INSERT能够实现 INSERT操作。它的输入是要被插入到最大堆A中的新元素的关键字。MAX-HEAP-INSERT首先通过增加一个关键字为负无穷的叶结点来扩展最大堆，然后调用 HEAP-INCREASE-KEY 作为新结点设置对应的关键字，同时保持最大堆的性质

MAX-HEAP-INSERT(A, key)
	A.heap-size = A.heap-size + 1
	A[A.heap-size] = -∞
	HEAP-INCREASE-KEY(A, A.heap-size, key)

MAX-HEAP-INSERT的运行时间为 O(lgn)

在一个包含n个元素的堆中，所有优先级队列的操作都可以在O(lgn)时间内完成

4、最大优先级队列应用在共享计算机系统的作业调度：最大优先队列记录将要执行的各个作业以及它们之间的相对优先级。当一个作业完成或者被中断后，调度器调用EXTRACT-MAX从所有的等待作业中，选出具有最高优先级的作业来执行。在任何时候，调度器可以调用INSERT把一个新作业加入到队列中来

5、在用堆来实现优先队列时，需要在堆中的每个元素里存储对应对象的句柄，其准确含义依赖于具体程序
在重新确定堆元素位置时，也需要更新相应应用程序对象中的数组下标

6、在HEAP-INCREASE-KEY的第5行的交换操作中，利用INSERTION-SORT内循环部分的思想，只用一次赋值就完成这一交换操作

HEAP-INCREASE-KEY(A, i, key)
    if key < A[i]
        error "new key is smaller than current key"
    while i > 1 and A[PARENT(i)] < key
        A[i] = A[PARENT(i)]
        i = PARENT(i)
    A[i] = key    

// 原来的代码
A[i] = key
while i > 1 and A[PARENT(i)] < A[i]
	exchange A[i] with A[PARENT(i)]
	i = PARENT(i)

7、一个时间复杂度为O(nlgk)的算法，它能够将k个有序链表合并为一个有序链表，这里n是所有输入链表包含的总的元素个数

MERGE-ORDER-LIST(A, n, k)
    let R be a new min-heap
    i = 0
    for j = 1 to n
        i += 1
        i %= k
        if A[i].length ≥ 1
            MIN-HEAP-INSERT(R, A[i][1])
            A[i].REMOVE-HEAD()