第7章快速排序

最新推荐文章于 2024-05-07 06:48:00 发布

江湖乱飘

最新推荐文章于 2024-05-07 06:48:00 发布

阅读量2.5k

点赞数 3

分类专栏：《算法导论》（原书第3版）练习和思考题答案

本文链接：https://blog.csdn.net/sinat_41619658/article/details/83089505

版权

《算法导论》（原书第3版）练习和思考题答案专栏收录该内容

14 篇文章 245 订阅

订阅专栏

7.1 快速排序的描述

7.1-1

PARTITION在数组A=<13，19，9，5，12，8，7，4，21，2，6，11>上的操作过程。

7.1-2

当数组A[p..r]中的元素都相同时，PARTITION返回的q值是r。修改PARTITION，使得当数组A[p..r]中所有元素的值都相同时， $q=\left \lfloor (p+r)/2 \right \rfloor$ 。

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⌉

7.1-3

证明：因为在规模为n的子数组上，PARTITION需要迭代n次，每次迭代的时间复杂度为 $\Theta (1)$ ，所以PARTITION的时间复杂度为 $\Theta (n)$ 。

7.1-4

修改QUICKSORT，使得它能够以非递增序进行排序。

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)

7.2 快速排序的性能

7.2-1

令 $\Theta (n)=dn$ ，对某两个恰当选出的常数 $c_{1},c_{2}>0$ ，假定 $c_{1}n^{2}\leqslant T(n)\leqslant c_{2}n^{2}$ 对所有正数 m<n 都成立，特别是对于m=n-1，有 $c_{1}(n-1)^{2}\leqslant T(n-1)\leqslant c_{2}(n-1)^{2}$ 。将其代入递归式，得到 $c_{1}(n-1)^{2}+dn\leqslant T(n)\leqslant c_{2}(n-1)^{2}+dn\Rightarrow$ $c_{1}n^{2}\leqslant c_{1}n^{2}+c_{1}+(d-2c_{1})n\leqslant T(n)\leqslant c_{2}n^{2}+c_{2}+(d-2c_{2})n\leqslant c_{2}n^{2}$ 。其中，只要 $2c_{1}\leqslant d\leqslant 2c_{2},\frac{c_{2}}{2c_{2}-d}\leqslant n\leqslant \frac{c_{1}}{2c_{1}-d}$ ，最后一步都会成立。所以递归式 $T(n)=\Theta (n^{2})$ 。

7.2-2

当数组A的所有元素都具有相同值时，QUICKSORT的时间复杂度是 $\Theta (n^{2})$ 。

7.2-3

证明：当数组A包含的元素不同，并且是按降序排列的时候，QUICKSORT的每一次递归调用划分产生的两个子问题分别包含了n-1个元素和0个元素，这也是QUICKSORT的最坏情况，根据7.2节开头的论述，此时QUICKSORT的时间复杂度是 $\Theta (n^{2})$ 。

7.2-4

证明：当输入序列越有序，INSERTION-SORT的性能越优，QUICKSORT的性能越劣，当输入数组已经完全有序时，插入排序的时间复杂度为 O(n) ，快速排序的时间复杂度为 $\Theta (n^{2})$ 。所以在一个对几乎有序的输入序列进行排序的问题上，INSERTION-SORT的性能往往要优于QUICKSORT。

7.2-5

证明：假设叶结点的最小深度是 $d_{min}$ ，最大深度是 $d_{max}$ 。则 $n\alpha ^{d_{min}}=1\Rightarrow \alpha ^{d_{min}}=\frac{1}{n}\Rightarrow d_{min}=\log_{\alpha }{\frac{1}{n}}=-\frac{\lg{n}}{\lg{\alpha }}$ ， $n(1-\alpha) ^{d_{max}}=1\Rightarrow (1-\alpha) ^{d_{max}}=\frac{1}{n}\Rightarrow d_{max}=\log_{1-\alpha }{\frac{1}{n}}=-\frac{\lg{n}}{\lg{(1-\alpha )}}$ 。所以，在相应的递归树中，叶结点的最小深度大约是 $-\lg{n}/\lg{\alpha }$ ，最大深度是 $-\lg{n}/\lg{(1-\alpha )}$ 。

7.3 快速排序的随机化版本

7.3-1

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

7.3-2

在RANDOMIZED-QUICKSORT的运行过程中，在最坏情况下，随机数生成器RANDOM被调用了 $T(n)=T(n-1)+1=\Theta (n)$ 次，在最好情况下，随机数生成器RANDOM被调用了 $T(n)=2T(n/2)+1=\Theta (n)$ 。

7.4 快速排序分析

7.4.1 最坏情况分析

7.4.2 期望运行时间

7.4-1

证明：令 $\Theta (n)=dn$ ，对某个恰当选出的常数c>0，假定 $T(n)\geqslant cn^{2}$ 对所有正数m<n都成立，特别是对于 $m=q,n-q-1(0\leqslant q\leqslant n-1)$ ，有 $T(q)\geqslant cq^{2}$ ， $T(n-q-1)\geqslant c(n-q-1)^{2}$ 。将其代入递归式，得到 $T(n)=\max_{0\leqslant q\leqslant n-1}{(T(q)+T(n-q-1))}+dn\geqslant$ $\max_{0\leqslant q\leqslant n-1}{(cq^{2}+c(n-q-1)^2)}+dn\geqslant cn^{2}-2cn+c+dn\geqslant cn^{2}+(d-2c)n$ $\geqslant cn^{2}$ 。其中，只要 $d\geqslant 2c$ ，最后一步都会成立。所以递归式 $T(n)=\Omega (n^{2})$ 。

7.4-2

证明：在最好情况下，快速排序每次调用PARTITION时都将数组划分成相等的两个部分，此时 $T(n)=2T(n/2)+\Theta (n)$ 。运用4.5节的主方法求得： $T(n)=\Omega (n\lg{n})$ ，所以快速排序的运行时间为 $\Omega (n\lg{n})$ 。

7.4-3

证明： $q^{2}+(n-q-1)^{2}=q^{2}+(n^{2}+q^{2}+1-2nq+2q-2n)=$ $2q^{2}-(2n-2)q+n^{2}-2n+1$ ，此一元二次函数的对称轴为 $q=-\frac{-(2n-2)}{2\cdot 2}=\frac{n-1}{2}$ ，所以当q=0或q=n-1时， $q^{2}+(n-q-1)^{2}$ 取得最大值。

7.4-4

证明： $E[X]=\sum _{i=1}^{n-1}{\sum _{j=i+1}^{n}{\frac{2}{j-i+1}}}=\sum _{i=1}^{n-1}{\sum _{k=1}^{n-i}{\frac{2}{k+1}}}\geqslant \sum _{i=1}^{n-1}{\sum _{k=1}^{n-i}{\frac{2}{2k}}}=$ $\sum _{i=1}^{n-1}{\Omega (\lg{n})}=\Omega (n\lg{n})$ ，所以RANDOMIZED-QUICKSORT期望运行时间是 $\Omega (n\lg{n})$ 。

7.4-5

证明：当对数组调用快速排序直至子数组的长度小于k时，共调用了 $\lg{(n/k)}$ 次迭代调用，时间复杂度为 $O(n\lg{(n/k)})$ 。当上层的快速排序调用返回后，对整个数组运行插入排序时，因为下标为i的元素肯定小于下标为i+k的元素，所以插入排序的内层循环每次最多迭代k轮，外层循环固定迭代n轮，时间复杂度为 O(nk) 。因此，这一排序算法的期望时间复杂度为 $O(nk+n\lg{(n/k)})$ 。

从理论角度说明该如何选择k： $nk+n\lg{(n/k)}\leqslant n\lg{n}\Rightarrow k+\lg{(n/k)}\leqslant \lg{n}\Rightarrow k\leqslant \lg{k}$ ，这样的k不可能存在。在加入常数系数的情况下进行分析： $c_{1}nk+c_{2}n\lg{(n/k)}\leqslant c_{2}n\lg{n}\Rightarrow c_{1}k+c_{2}\lg{(n/k)}\leqslant c_{2}\lg{n}\Rightarrow k\leqslant \frac{c_{2}}{c_{1}}\lg{k}$ ，可见k的取值取决于插入排序和快速排序的时间复杂度常熟系数的相对大小，这个需要实践才能得出结论。

思考题

7-1

a.说明HOARE-PARTITION在数组A=<13，19，9，5，12，8，7，4，11，2，6，21>上的操作过程，并说明在每一次执行第4~13行while循环时数组元素的值和辅助变量的值。

b.证明：因为i单调递增，j单调递减，下标小于i的数组元素都小于x，下标大于j的数组元素都大于等于x，当j单调递减时不会小于i，当i单调递增时不会大于j+1，又因为子数组A[p..r]至少包含来2个元素，所以下标i和j可以使我们不会访问在子数组A[p..r]以外的数组A的元素。

c.证明：根据上一问的证明过程，当HOARE-PARTITION结束时， $p\leqslant i,j\leqslant r$ 且i=j+1，所以 $p\leqslant j<r$ 。

d.证明：先定义循环不变式：在开始第4~13行while循环的每次迭代时，A[p..i-1]中的每个元素都小于或等于A[j+1..r]中的元素。证明如下：

初始化：在循环的第一次迭代之前，有i=p-1，j=r+1。此时A[p..i-1]和A[j+1..r]中都没有元素，循环不变式成立。

保持：每次循环时j先单调递减直至 $A[j]\leqslant x$ 也即下标大于j的数组元素都大于等于x，i再单调递增直至 $A[i]\geqslant x$ 也即下标小于i的数组元素都小于等于x，此时A[p..i-1]中的每个元素都小于或等于A[j+1..r]中的元素。

终止：终止时i=j+1，根据循环不变式，A[p..j]中的每一个元素都小于或等于A[j+1..r]中的元素。

e.利用HOARE-PARTITION，重写QUICKSORT算法。

HOARE-PARTITION(A, p, r)
    x = A[p]
    i = p - 1
    j = r + 1
    while TRUE
        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

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

7-2

a.如果所有输入元素的值都相同，那么随机化快速排序的运行时间会是 $\Theta (n^{2})$ 。

b.修改PARTITION代码来构造一个新的PARTITION'(A，p，r)，它排列A[p..r]的元素，返回值是两个数组下标q和t，其中 $p\leqslant q\leqslant t\leqslant r$ ，且有

A[q..t]中的所有元素都相等。
A[p..q-1]中的每个元素都小于A[q]。
A[t+1..r]中的每个元素都大于A[q]。

与PARTITION类似，新构造的PARTITION'的时间复杂度是 $\Theta (r-p)$ 。

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

c.将RANDOMIZED-PARTITION过程改为调用PARTITION'，并重新命名为RANDOMIZED-PARTITION'。修改RANDOMIZED-QUICKSORT的代码构造一个新的RANDOMIZED-QUICKSORT'(A，p，r)，它调用RANDOMIZED-PARTITION'，并且只有分区内的元素互不相同的时候才做递归调用。

RANDOMIZED-PARTITION'(A, p, r)
    i = RANDOM(p, r)
    exchange A[r] with A[i]
    return PARTITION'(A, p, r)

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

d.在7.4.2节中的分析方法中，假设每个元素的值是互异的，因此，一旦一个满足 $z_{i}<x<z_{j}$ 的主元x被选择后，就知道 $z_{i}$ 和 $z_{j}$ 以后再也不可能被比较了。另一种情况，如果 $z_{i}$ 在 $Z_{ij}$ 中的所有其他元素之前被选为主元，那么 $z_{i}$ 就将与 $Z_{ij}$ 中除了它自身以外的所有元素进行比较。类似地，如果 $z_{j}$ 在 $Z_{ij}$ 中其他元素之前被选为主元，那么 $z_{j}$ 将与 $Z_{ij}$ 中除自身以外的所有元素进行比较。

在QUICKSORT'中，一旦一个主元x被选择后，所有与x相等的元素在经历过一轮比较后将不再参与比较，其余分析不变。

7-3

a.证明：给定一个大小为n的数组，PARTITION过程等可能地选择一个元素作为主元，共有n个元素，所以任何特定元素被选为主元的概率为1/n。 $E[X_{i}]=Pr$ {第i小的元素被选为主元}=1/n。

b.证明：因为指示器随机变量 $X_{i}$ =I{第i小的元素被选为主元}，所以当第q小的元素被选为主元时， $X_{q}=1$ 。即时间复杂度为 $\Theta (n)$ 的PARTITION过程返回后，第q小的元素被选为主元，数组被分成长度分别为q-1和n-q的两个数组，所以 $T(n)=\sum _{q=1}^{n}{X_{q}(T(q-1)+T(n-q)+\Theta (n))}$ 。因此， $E[T(n)]=E[\sum _{q=1}^{n}{X_{q}(T(q-1)+T(n-q)+\Theta (n))}]$ 。

c.证明： $E[T(n)]=E[\sum _{q=1}^{n}{X_{q}(T(q-1)+T(n-q)+\Theta (n))}]=\sum _{q=1}^{n}{E[X_{q}(T(q-1)+T(n-q)+\Theta (n))]}$ $=\sum _{q=1}^{n}{E[X_{q}]E[T(q-1)+T(n-q)+\Theta (n)]}=\frac{1}{n}\sum _{q=1}^{n}{E[T(q-1)+T(n-q)+\Theta (n)]}$ $=\frac{1}{n}\sum _{q=1}^{n}{E[T(q-1)+T(n-q)]}+\Theta (n)=\frac{2}{n}\sum _{q=2}^{n-1}{E[T(q)]}+\Theta (n)$ 。

d.证明： $\sum _{k=2}^{n-1}{k\lg{k}}=\sum _{k=2}^{\left \lceil n/2 \right \rceil-1}{k\lg{k}}+\sum _{\left \lceil n/2 \right \rceil}^{n-1}{k\lg{k}}\leqslant \sum _{k=2}^{\left \lceil n/2 \right \rceil-1}{k\lg{(\left \lceil n/2 \right \rceil-1)}}+\sum _{\left \lceil n/2 \right \rceil}^{n-1}{k\lg{(n-1)}}\leqslant$ $\sum _{k=2}^{\left \lceil n/2 \right \rceil-1}{k\lg{\frac{n}{2}}}+\sum _{\left \lceil n/2 \right \rceil}^{n-1}{k\lg{(n-1)}}\leqslant \sum _{k=2}^{\left \lceil n/2 \right \rceil-1}{k(\lg{n}-1)}+\sum _{\left \lceil n/2 \right \rceil}^{n-1}{k\lg{n}}$ $\leqslant \lg{n}\sum _{k=2}^{\left \lceil n/2 \right \rceil-1}{k}-\sum _{k=2}^{\left \lceil n/2 \right \rceil-1}{k}+\lg{n}\sum _{\left \lceil n/2 \right \rceil}^{n-1}{k}=\lg{n}\sum _{k=2}^{n-1}{k}-\sum _{k=2}^{\left \lceil n/2 \right \rceil-1}{k}$ $\leqslant \lg{n}\sum _{k=2}^{n-1}{k}-\sum _{k=2}^{n/2-1}{k}=\frac{n^{2}-n-2}{2}\lg{n}-\frac{\frac{n^{2}}{4}-\frac{n}{2}-2}{2}$ $=\frac{1}{2}n^{2}\lg{n}-\frac{1}{8}n^{2}+(\frac{n}{4}+1-(\frac{n}{2}+1)\lg{n})\leqslant \frac{1}{2}n^{2}\lg{n}-\frac{1}{8}n^{2}$ 。

e.证明：令 $\Theta (n)=dn$ ，对于某个恰当选出的正常数a，假定 $E[T(n)]\leqslant an\lg{n}$ 对于所有正数q<n都成立。将其代入递归式，得到 $E[T(n)]=\frac{2}{n}\sum _{q=2}^{n-1}{E[T(q)]}+\Theta (n)\leqslant \frac{2}{n}\sum _{q=2}^{n-1}{aq\lg{q}}+dn\leqslant$ $\frac{2}{n}a(\frac{1}{2}n^{2}\lg{n}-\frac{1}{8}n^{2})+dn=an\lg{n}-\frac{a}{4}n+dn\leqslant an\lg{n}$ 。其中，只要 $d\leqslant \frac{a}{4}$ ，最后一步都会成立。所以公式(7.6)中的递归式有解 $E[T(n)]=\Theta (n\lg{n})$ 。

7-4

a.证明：在调用PARTITION后，TAIL-RECURSIVE-QUICKSORT(A，1，A.length)先是递归调用了左边的子数组，再把p的值设为右边的子数组的起始下标，此时下标p和r表示的是右边的子数组，然后重新开始循环，直至PARTITION划分的右边的子数组不存在，此时数组已经全部有序。所以，TAIL-RECURSIVE-QUICKSORT(A，1，A.length)能正确地对数组A进行排序。

b.当一个包含n个元素的数组已经有序时，针对此数组的TAIL-RECURSIVE-QUICKSORT的栈深度是 $\Theta (n)$ 。

c.修改TAIL-RECURSIVE-QUICKSORT的代码，使其最坏情况下栈深度是 $\Theta (\lg{n})$ ，并且能够保持 $O(n\lg{n})$ 的期望时间复杂度。

TAIL-RECURSIVE-QUICKSORT(A, p, r)
    while p < r
        // Partition and sort larger subarray.
        q = PARTITION(A, p, r)
        if 2q > p + r
            TAIL-RECURSIVE-QUICKSORT(A, p, q-1)
            p = q + 1
        else TAIL-RECURSIVE-QUICKSORT(A, q+1, r)
            r = q - 1

7-5

a. $p_{i}=Pr\{x=A'[i]\}=\frac{(i-1)(n-i)}{C_{n}^{3}}=\frac{(i-1)(n-i)}{\frac{n!}{3!(n-3)!}}=\frac{6(i-1)(n-i)}{n(n-1)(n-2)}$ 。

b.在平凡实现中，选择 $x=A'[\left \lfloor (n+1)/2 \right \rfloor]$ （即A[1..n]的中位数）的值作为主元的概率为1/n。在三数取中法实现中，选择 $x=A'[\left \lfloor (n+1)/2 \right \rfloor]$ （即A[1..n]的中位数）的值作为主元的概率为 $\frac{6(\left \lfloor (n+1)/2-1 \right \rfloor)(n-\left \lfloor (n+1)/2 \right \rfloor)}{n(n-1)(n-2)}=\frac{6\left \lfloor \frac{n-1}{2} \right \rfloor\left \lceil \frac{n-1}{2} \right \rceil}{n(n-1)(n-2)}$ ，与平凡实现相比，此概率增加了 $\frac{\frac{6\left \lfloor \frac{n-1}{2} \right \rfloor\left \lceil \frac{n-1}{2} \right \rceil}{n(n-1)(n-2)}}{\frac{1}{n}}=\frac{6\left \lfloor \frac{n-1}{2} \right \rfloor\left \lceil \frac{n-1}{2} \right \rceil}{(n-1)(n-2)}$ 。假设 $n\rightarrow \infty$ ，这一概率的极限值为 $\lim_{n\rightarrow \infty }{\frac{6\left \lfloor \frac{n-1}{2} \right \rfloor\left \lceil \frac{n-1}{2} \right \rceil}{(n-1)(n-2)}}=\lim_{n\rightarrow \infty }{\frac{6(\frac{n-1}{2})^{2}}{(n-1)(n-2)}}=\frac{6}{4}=1.5$ 。

c.如果定义一个“好”划分意味着主元选择 x=A'[i] ，其中 $n/3\leqslant i\leqslant 2n/3$ 。在平凡实现中，得到一个好划分的概率为 1/3 。在三数取中法实现中，得到一个好划分的概率为 $\lim_{n\rightarrow \infty }{\sum _{i=n/3}^{2n/3}{\frac{6(i-1)(n-i)}{n(n-1)(n-2)}}}=\lim_{n\rightarrow \infty }{\frac{6}{n(n-1)(n-2)}\sum _{i=n/3}^{2n/3}{(i-1)(n-i)}}=$ $\lim_{n\rightarrow \infty }{\frac{6}{n(n-1)(n-2)}\int _{n/3}^{2n/3}{(i-1)(n-i)}di}=\lim_{n\rightarrow \infty }{\frac{6}{n(n-1)(n-2)}(-\frac{i^{3}}{3}+\frac{n+1}{2}i^{2}-ni)\Big|_{n/3}^{2n/3}}=$ $\lim_{n\rightarrow \infty }{\frac{6(\frac{13}{162}n^{3}-\frac{1}{6}n^{2})}{n(n-1)(n-2)}}=\lim_{n\rightarrow \infty }{\frac{\frac{13}{27}n^{3}-n^{2}}{n(n-1)(n-2)}}=\frac{13}{27}$ ，与平凡实现相比，这种实现中得到一个好划分的概率增加了 $\frac{\frac{13}{27}}{\frac{1}{3}}=\frac{13}{9}\approx 1.44$ 。

d.证明：根据7.2节对快速排序的性能的探讨得出的结论，只要划分是是常数比例的，算法的运行时间总是 $O(n\lg{n})$ 。三数取中法只是增加了得到一个好划分的概率，所以对快速排序而言，三数取中法只影响其时间复杂度 $\Omega (n\lg{n})$ 的常数项因子。

7-6

a.为n个形如 $[a_{i},b_{i}]$ 的闭区间，其中 $a_{i}\leqslant b_{i}$ ，实现这些区间的模糊排序，即对j=1，2，...，n，生成一个区间的排列 $<i_{1},i_{2},...,i_{n}>$ ，且存在 $c_{j}\in [a_{i},b_{i}]$ ，满足 $c_{1}\leqslant c_{2}\leqslant ...\leqslant c_{n}$ 。设计一个随机算法，具有算法的一般结构，它可以对左边端点（即 $a_{i}$ 的值）进行快速排序，同时它也能利用区间的重叠性质来改善时间性能。（当区间重叠越来越多的时候，区间的模糊排序问题会变得越来越容易。算法能充分利用这一重叠性质。）

FUZZ-RANDOMIZED-PARTITION(A, B, I, p, r)
    i = RANDOM(p, r)
    exchange I[r] with I[i]
    left = A[I[r]]
    right = B[I[r]]
    // Find an intersection of the pivot and other intervals
    for j = p to r-1
        if left ≤ B[I[j]] and right ≥ A[I[j]]
            left = max(left, A[I[j]])
            right = min(right, B[I[j]])
    // Partition before the intersection
    q = p - 1
    for j = p to r-1
        if B[I[j]] < left
            q = q + 1
            exchange I[q] with I[j]
    // Partition equal the intersection
    t = q
    for j = t+1 to r-1
        if left ≤ B[I[j]] and right ≥ A[I[j]]
            t = t + 1
            exchange I[t] with I[j]
    exchange I[t+1] with I[r]
    return q+1, t+1

FUZZ-RANDOMIZED-QUICKSORT(A, B, I, p, r)
    if p < r
        q, t = FUZZ-RANDOMIZED-PARTITION(A, B, I, p, r)
        FUZZ-RANDOMIZED-QUICKSORT(A, B, I, p, q-1)
        FUZZ-RANDOMIZED-QUICKSORT(A, B, I, t+1, r)

b.证明：算法中FUZZ-RANDOMIZED-PARTITION过程的时间复杂度为 $\Theta (n)$ ，在一般情况下，算法需要递归调用 $\lg{n}$ 次，所以算法的期望运行时间为 $\Theta (n\lg{n})$ 。但是，当所有的区间都有重叠的时候，算法调用一次就结束，所以算法的期望运行时间为 $\Theta (n)$ 。

江湖乱飘

关注

3
点赞
踩
16

收藏

觉得还不错? 一键收藏
2
评论
第7章快速排序

7.1 快速排序的描述7.1-1PARTITION在数组A=&lt;13，19，9，5，12，8，7，4，21，2，6，11&gt;上的操作过程。7.1-2当数组A[p..r]中的元素都相同时，PARTITION返回的q值是r。修改PARTITION，使得当数组A[p..r]中所有元素的值都相同时，。PARTITION(A, p, r) x = A[r] ...
复制链接

扫一扫