快速排序详解

最新推荐文章于 2024-09-12 15:56:42 发布

LoDolores

最新推荐文章于 2024-09-12 15:56:42 发布

阅读量779

点赞数

分类专栏：算法文章标签：算法排序快速排序

本文链接：https://blog.csdn.net/LoDolores/article/details/47159375

版权

算法专栏收录该内容

2 篇文章 0 订阅

订阅专栏

描述
实现
稳定性
其它优化
参考资料

描述

快速排序（Quicksort） 由 C. A .R. Hoare 于1962年提出。

它采用分治策略：

少于2个元素的数组不用管。
分解将数组分割为两个子数组，第一个子数组的所有元素不大于第二个子数组的所有元素。
解决递归地排序两个子数组。
合并啥也不用做，数组已经被原址排好了。

根据以上描述，容易写出快速排序的伪代码：

QUICKSORT(A, p, q)
/* Sort A[p..q] */
    if q > p
        Partition A into 2 subarrays: A[p..r], A[r+1..q]
        QUICKSORT(A, p, r)
        QUICKSORT(A, r+1, q)

实现

自然，快速排序的效率主要由分解步骤决定。通常，我们从数组中选取一个主元（pivot），不大于主元的元素划到主元左边，不小于主元的元素划到主元右边。

以 A = {13, 19, 7, 41, 2, 37, 5, 11} 为例，QUICKSORT(A, 1, 8) 的执行过程如下（主元是x，这里选取第1个元素作为主元，主元划分到左边，和主元相等的元素划分到右边；数组索引从1开始）：

1	2	3	4	5	6	7	8
x=13	19	7	41	2	37	5	11
x=7	2	5	11	13	x=19	41	37
x=2	5	7	x=11	13	19	x=41	37
2	x=5	7	11	13	19	37	41
2	5	7	11	13	19	37	41

接下来，我们设计划分算法。

一个简单的想法是这样：开一个数组，从左往右复制划分到主元左边的元素，从右往左复制划分到主元右边的元素，主元夹在两者之间，用这个新数组覆盖原数组。开一个新数组是必须的吗？如果不是，快速排序将获得相对于归并排序的优势——原址。所为原址排序，即任何时刻最多只有常数个数据在数组之外。联想冒泡排序、插入排序，它们通过比较和交换实现原址排序。能否把比较和交换运用到我们的划分算法里呢？

单向划分

PARTITION1

经过思考，我们（实际上最初由Nico Lomuto）设计了以下算法：

PARTITION1(A, p, q)
    x = A[p] // pivot
    j = p
    for i = p+1 to q
        if A[i] < x
            j = j+1
            exchange A[i] with A[j]
    exchange A[p] with A[j]
    return j

for 循环的不变式：A[p+1..j] < x ≤ A[j+1..i-1]。初始情况，A[p+1..j]、A[j+1..i-1]是空数组。设A[p+1..j]里的元素小于x，A[j+1..i-1]里的元素大于等于x；若A[i]小于x，交换前，A[j+1]大于等于x，因此交换后A[p+1..j+1]均小于x，A[j+2..i]均大于等于x，由于赋值 j = j+1，循环不变式依然成立。结束后，i = q+1，因此A[p+1..j]里的元素小于x，A[j+1..q]里的元素大于等于x。再交换主元A[p]和A[j]，形成A[p..j-1]里的元素小于x，A[j]等于x，A[j+1..q]里的元素大于等于x。

换言之，前方发现小于x的元素，就和后方已知不小于x的元素换个位置，并且让它接过标识两类元素分界处的旗子。最后，x和举旗子的那位换位置，并接过旗子，于是，它身后的所有元素小于x，面前的所有元素大于等于x。

PARTITION2

通过改进循环不变式，循环外的交换是可以省去的：

PARTITION2(A, p, q)
    x = A[p] // pivot
    j = p
    for i = p+1 to q
        if A[i] < x
            A[j] = A[i]
            A[i] = A[j+1]
            A[++j] = x
    return j

这是我的方案，不变式为 A[p..j-1] < A[j] ≤ A[j+1]。

PARTITION3

Bob Sedgewick发现，可以将Lomuto的划分方案修改为从右向左进行，并且使用A[p]作为哨兵：

PARTITION3(A, p, q)
    x = A[p]
    j = i = q+1
    do
        repeat
            i = i-1
        until A[i] >= x
        exchange A[--j] with A[i]
    while i > p
    return j

或等价地写为：

PARTITION3(A, p, q)
    x = A[p]
    j = q+1
    for i = q downto p
        if A[i] >= x
            exchange A[i] with A[--j]
    return j

第一种写法去除了不必要的i和q间的比较。

不变式：A[i..j-1] < x ≤ A[j..q]。终止时，i = p，A[j] = x，因此A[p..j-1] < A[j] ≤ A[j+1..q]。

PARTITION[123]的时间复杂度均为 $\Theta(n)$ ，所有优化仅限常数因子。

非随机算法

相应地，完整的QUICKSORT1如下：

QUICKSORT1(A, p, q)
    if p < q
        r = PARTITION[123](A, p, q)
        QUICKSORT1(A, p, r-1)
        QUICKSORT1(A, r+1, q)

这里有一个小改动。因为A[p..r-1]中元素小于A[r]，A[r]小于等于A[r+1..q]中元素，所以A[r]的位置已确定，在接下来的递归步骤中可以去掉。为了正确性这个改动是必须的，否则当A[p]是数组中最大元素时算法不会终止。

设QUICKSORT1的运行时间为 $T(n)$ ，则 $T(n) = T(m)+T(n-m-1)+\Theta(n), 0 \le m \le n-1$ 。当m=0或(n-1)时， $T(n) = \Theta(n^2)$ ，这是QUICKSORT1的最坏情况运行时间。

随机算法

两个子数组被划分越均匀，快速排序的时间效率越高。在PARTITION1中，选择第1个元素作为主元，因此当数组A已有序时，QUICKSORT1达到最坏运行时间。一个改进方案是随机选取一个元素与A[p]交换：

QUICKSORT2(A, p, q)
    if p < q
        i = randint(p, q) // a random number in [p, q]
        exchange A[i] with A[p]
        r = PARTITION[123](A, p, q)
        QUICKSORT1(A, p, r-1)
        QUICKSORT1(A, r+1, q)

这样我们得到一个随机算法， $\mathbb{E}[T(n)]=O(n\lg n)$ 。

双向划分

PARTITION4

考虑了输入是有序数组，再考虑另一种极端情形——所有元素都相等。由Hoare设计的双向划分算法解决了这一问题。

PARTITION4(A, p, q)
    x = A[p]
    i = p-1
    j = q+1
    loop
        repeat
            j = j-1
        until A[j] <= x
        repeat
            i = i+1
        until A[i] >= x
        if i < j
            exchange A[i] with A[j]
        else
            return j

不变式（严格来讲最后一刻它是不满足的）：A[p..i] ≤ x ≤ A[j..q]。终止时p ≤ j < q。

设L为左边的有序区，R为右边的有序区。在repeat…until阶段，索引i、j不会超出范围。进入外部循环前，L、R为空。5～7行，A[p]扮演着哨兵的角色；6～8行运行一遍即停止；9~12行，若j>p，则经过交换L、R一定都是非空的，否则返回j，有A[p] ≤ x ≤ A[p+1..q]。此后，L、R起到了哨兵的作用，因此只需要在第9行检查i、j是否交叉。

当A[i]=A[j]=x时，交换照样进行，使j处于靠近数组中点的位置。所有元素都相等时，快速排序不会退化到 $\Theta(n^2)$ 。

使用双向划分

i、j交叉前一刻，所有元素已经非L即R，此后，j等于L的右边界，i等于R的左边界。对应的随机化QUICKSORT过程如下：

QUICKSORT3(A, p, q)
    if p < q
        exchange A[p] with A[randint(p, q)]
        r = PARTITION4(A, p, q)
        QUICKSORT4(A, p, r)
        QUICKSORT4(A, r+1, q)

由于p ≤ r < q，算法能停机。