算法导论总结索引 | 第二部分第七章：快速排序_快速排序的依赖条件是什么-CSDN博客

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

1、对于包含n个数的输人数组来说，快速排序是一种最坏情况时间复杂度为Θ(n²)的排序算法

虽然最坏情况时间复杂度很差，但是快速排序通常是实际排序应用中最好的选择，因为它的平均性能非常好：它的期望时间复杂度是Θ(n lgn)，而且 Θ(n lgn)中隐含的常数因子非常小

另外，它还能够进行原址排序，甚至在虚存环境中也能很好地工作

1、快速排序的描述（110）

1、分治思想
对一个典型的子数组 A[p…r] 进行快速排序的三步分治过程：

分解：数组A[p…r] 被划分为两个（可能为空）子数组 A[p…q-1] 和 A[q+1…r]，使得 A[p…q-1] 中的每一个元素都小于等于 A[q]，而A[q]也小于等于 A[q+1…r]中的每个元素
其中，计算下标q 也是划分过程的一部分

解决：通过递归调用快速排序，对子数组 A[p，q-1] 和 A[q+1…r] 进行排序

合并：因为子数组都是原址排序的，所以不需要合并操作；数组 A[p…r] 已经有序

QUICKSORT(A, p, r)
	if p < r
		q = PARTITION(A, p, r)
		QUICKSORT(A, p, q-1)
		QUICKSORT(A, q+1, r)

为了排序一个数组A的全部元素，初始调用是 QUICKSORT(A, 1, A.length)

2、数组的划分：算法的关键部分是 PARTITION 过程，它实现了对子数组 A[p…r] 的原址重排

PARTITION(A, p, r)
	x = A[r] // 主元，总是选 最后一个
	i = p - 1 // 开始到i是 更小的数字段，i到j是 更大的数字段
	for j = p to r - 1 // 待排数字段
		if A[j] <= x
			i = i + 1 // 选好目标位置
			exchange A[i] with A[j]
	exchange A[i + 1] with A[r]
	return i + 1 // 最后已经排好的p的 下标位置

PARTITION总是选择一个 x = A[r] 作为主元

循环不变量（快排核心：三个数字段（代码注释中也写了））：在第3-6行循环体的每一轮迭代开始时，对于任意数组下标k，有：
1）若 p<=k<=i，则 A[k] <= x
2）若 i+1 <= k <= j-1，则 A[k] > x
3）若 k = r，则 A[k] = x
对于下标j 到 r - 1，是待排数字段
快速排序过程
数组项A[r] 是主元x，浅阴影部分的数组元素都在划分的第一部分，其值都不大于x。深色阴影部分的元素都在划分的第二部分，其值都大于x。无阴影部分是还未分入这两个部分。最后白色元素就是x
交换过程
该循环不变量还可以证明正确性（111）

3、在PARTITION的最后两行中，通过将主元与最左的大于x的元素进行交换，就可以将主元移动到它在整个数组中的正确位置（最终位置）上，并返回主元的新下标，此时主元排序完毕

4、当数组 A[p…r] 中的元素都相同时，PARTITION返回的q值是什么？修改PARTITION，使当数组A[p…r] 中所有元素的值都相同时，q=⌊(p+r)/2⌋
当数组A[p…r]中的元素都相同时，PARTITION返回的q值是r

修改PARTITION，对主元素相等的元素进行计数处理，因为i会走到r-1，只要让n也走到r-1，最后返回 i + 1 - ⌈n/2⌉

PARTITION(A, p, r)
    x = A[r]
    i = p - 1
    n = 0
    for j = p to r-1
        if A[j] ≤ x
            if A[j] == x
                n = n + 1
            i = i + 1
            exchange A[i] with A[j]
    exchange A[i+1] with A[r]
    return i + 1 - ⌈n/2⌉

5、修改QUICKSORT，使得它能够以非递增序进行排序：大于等于时操作（i 往后推到 j的新位置，再交换：即开始的两个数字段换成大于主元的，接着的数字段换成小于主元的）

PARTITION(A, p, r)
    x = A[r]
    i = p - 1
    for j = p to r-1
        if A[j] ≥ x
            i = i + 1
            exchange A[i] with A[j]
    exchange A[i+1] with A[r]
    return i + 1
 
QUICKSORT(A, p, r)
    if p < r
        q = PARTITION(A, p, r)
        QUICKSORT(A, p, q-1)
        QUICKSORT(A, q+1, r)

2、快速排序的性能

1、快速排序的运行时间依赖于划分是否平衡，而平衡与否又依赖于用于划分的元素。如果划分是平衡的，那么快速排序算法性能与归并排序一样。如果划分是不平衡的，那么快速排序的性能就接近于插入排序了

2、最坏情况划分：当划分产生的两个子问题分别包含了n-1个元素和 0个元素时，假设算法的每一次递归调用中都出现了这种不平衡划分。划分操作的时间复杂度是 Θ(n)
算法代价
从直观上来看，每一层递归的代价可以被累加起来，结果为 Θ(n²)

在最坏情况下，快速排序算法的运行时间并不比插入排序更好。当数组已经完全有序时，快速排序的时间复杂度仍然为 Θ(n²)。而在同样的情况下，插入排序的时间复杂度为 O(n)

3、最好情况划分：在可能的最平衡的划分中，PARTITION得到的两个子问题的规模都不大于 n/2。这是因为其中一个子问题的规模为 ⌊n/2⌋，而另一个子问题的规模为 ⌈n/2⌉-1。此时，算法运行时间的递归式为：

根据主定理，上述递归式的解为 T(n) = Θ(n lgn)

4、平衡的划分：假设划分算法总是产生 9：1的划分，得到的快速排序时间复杂度的递归式
9：1划分递归式
树中每一层的代价都是cn，直到在深度 log10(n) = Θ(lgn) 处达到递归的边界条件时为止

任何一种常数比例的划分都会产生深度为 Θ(lgn) 的递归树，其中每一层的时间代价都是O(n)。因此，只要划分是常数比例的，算法的运行时间总是O(n lgn)

5、对于平均情况的直观观察：为了对快速排序的各种随机情况有一个清楚的认识，需要对遇到各种输人的出现频率做出假设。快速排序的行为依赖于输入元素中的元素的值的相对顺序，而不是特定值本身
与对雇佣问题所做的概率分析类似，这里也假设输人数据的所有排列都是等概率的

在一个差的划分后面接着一个好的划分，这种组合产生出三个子数组，大小分别为0、(n - 1) / 2 - 1 和（n - 1) / 2。这一组合的划分代价为Θ(n) + Θ(n - 1) = Θ(n)，代价并不比最有情况下的划分更差

因此，当好和差的划分交替出现时，快速排序的时间复杂度与全是好的划分时一样，仍然是 O(n lgn)。区别只是O符号中隐含的常数因子要略大一些
图片示意
6、当数组A的所有元素都具有相同值时，QUICKSORT的时间复杂度是 Θ(n²)

7、当数组A包含的元素不同，并且是按降序 / 顺序排列的时候，QUICKSORT的每一次递归调用划分产生的两个子问题分别包含了 n-1个元素和0个元素，这也是QUICKSORT的最坏情况，时间复杂度是 Θ(n²)

8、对几乎有序的输入序列进行排序，INSERTION-SORT的性能往往要优于 QUICKSORT：当输入数组已经完全有序时，插入排序的时间复杂度为 O(n)，快速排序的时间复杂度为 Θ(n²) 。所以在一个对几乎有序的输入序列进行排序的问题上，INSERTION-SORT 的性能往往要优于 QUICKSORT（容易形成不平衡的分割）

3、快速排序的随机化版本

1、前提假设是：输人数据的所有排列都是等概率的。但是在实际工程中，这个假设并不会总是成立。通过在算法中引入随机性，从而使得算法对于所有的输入都能获得较好的期望性能。很多人都选择随机化版本的快速排序作为大数据输人情况下的排序算法

2、采用随机抽样的随机化技术，与始终采用 A[r] 作为主元的方法不同，随机抽样是从子数组 A[p…r] 随机选择一个元素作为主元。保证主元素 x=A[r] 是等概率地从子数组的 r - p + 1个元素中选取的，因为主元素是随机选取的，期望在评价情况下，对输入数组的划分是比较均衡的

对PARTITION 和 QUICKSORT的代码的改动非常小。在新的划分程序中，只是在真正进行划分前进行一次交换

// 增加的代码（进行交换）
RANDOMIZED-PARTITION(A, p, r)
	i = RANDOM(p, r)
	exchange A[r] with A[i]
	return PARTITION(A, p, r)

新的快速排序不再调用PARTITION，而是调用RANDOMIZED-PARTITION
在RANDOMIZED-QUICKSORT的运行过程中，在最坏情况下，随机数生成器RANDOM 被调用了 T(n) = T(n - 1) + 1 = Θ (n) 次，在最好情况下，随机数生成器RANDOM 被调用了T(n) = 2T(n / 2) + 1 = Θ (n)

3、因为随机化算法引入了随机性，从而使得算法对于所有的输入都能获得较好的期望性能。所以分析随机化算法的期望运行时间，而不是其最坏运行时间

4、快速排序分析

快速排序更严谨的分析。首先从最坏情况开始，其方法可以用于 QUICKSORT 和 RANDOMIZED-QUICKSORT 的分析，然后给出 RANDOMIZED-QUICKSORT 的期望运行时间

4.1 最坏情况分析（116）

略

4.2 期望运行时间

1、运行时间和比较操作：QUICKSORT 和 RANDOMIZED-QUICKSORT 除了如何选择主元元素有差异以外，其他方
面完全相同。因此，可以在讨论QUICKSORT和PARTITION的基础上分析 RANDOMIZED-QUICKSORT

每次对PARTITION的调用时，都会选择一个主元元素，而且该元素不会被包含在后续的对QUICKSORT 和 PARTITION的递归调用中
每次对PARTITION的调用时，都会选择一个主元元素，而且该元素不会被包含在后续的对QUICKSORT和PARTITION的递归调用中，因此，在快速排序算法的整个执行期间，至多只可能调用 PARTITION操作 n次
调用一次PARTITION的时间为 O(1）再加上一段循环时间，这段时间与第3~6行中for循环的选代次数成正比。这一for循环的每一轮迭代都要在第4行进行一次比较：比较主元元素与数组A中另一个元素。因此，如果可以统计第4行被执行的总次数，就能够给出在QUICKSORT的执行过程中，for循环所花时间的界

假设在PARTITION的第4行中所做比较的次数为 X，那么QUICKSORT的运行时间为 O(n + X)

2、待排数组中每一对元素至多比较一次。因为各个元素只与主元元素进行比较，并且在某一次 PARTITION 调用结束后，该次调用中用到的主元元素就再也不会与其他元素进行比较了

考虑的是比较操作是否在算法执行过程中任意时间发生，而不是局限在循环的一次迭代或对PARTITION的一次调用中是否发生。因为每一对元素至多比较一次，可以刻画算法的总比较次数
算法总比较次数
对上式两边取期望
对上式两边取期望

考虑两个元素何时不会进行比较：以数组 {1，2，3，4，5，6，7，8，9，10} 为例，假设第一个主元是7。对 PARTITION的第一次调用就将这些输入数字划分为两个集合：{1，2，3，4，5，6} 和 {8，9，10} 。在这个过程中，主元7 要与所有其他元素进行比较。但是第一个集合中的任何一个元素（比如2）没有（也不会）与第二个元素中的任何元素（比如9）进行比较

假设每个元素的值是互异的，一旦一个满足Zi < x <Zj 的主元x 被选择后，就知道以后再也不可能被比较了
另一种情况，如果Zi在Zij中的所有其他元素之前被选为主元，那么Zi就将与Zij中除了它自身以外的所有元素进行比较

在Zij中的某个元素被选为主元之前，整个集合Zij的元素都属于某一划分的同一分区。因此，Zij中的任何元素都会等可能地被首先选为主元，因为集合Zij中有 j-i+1个元素，并且主元的选择是随机且独立的，所以任何元素被首先选为主元的概率是 1 / (j - i + 1)
过程式
第二行成立的原因在于其中涉及的两个事件是互斥的
计算总期望
计算这个累加和时，需要将变量做个变换（k = j - i）
做变换后求值
使用RANDOMIZED-PARTITION，在输入元素互异的情况下，快速排序算法的期望运行时间为O(n lgn)

3、在最好情况下，快速排序每次调用PARTITION时都将数组划分成相等的两个部分，此时 T(n) = 2T(n/2) + Θ(n)。主方法求得：T(n) = Ω(n lgn)，所以快速排序的运行时间为 Ω(n lgn)

4、当对一个长度小于L的子数组调用快速排序时，让它不做任何排序就返回，当上层的快速排序调用返回后，对整个数组运行插人排序来完成排序过程
当对数组调用快速排序直至子数组的长度小于k时，共调用了 lg(n/k)次迭代调用，时间复杂度为 O(n lg(n/k))
当上层的快速排序调用返回后，对整个数组运行插入排序时，因为下标为i的元素肯定小于下标为i+k的元素，所以插入排序的内层循环每次最多迭代k轮，外层循环固定迭代n轮，时间复杂度为O(nk)。因此，这一排序算法的期望时间复杂度为 O(nk + n lg(n / k))