快速排序中的堆栈深度

7.1节中的QUICKSORT算法包含有两个对自身递归调用。在调用PARTITION后，左边的子数组和右边的子数组分别被递归排序。

QUICKSORT中第二次递归调用并不是必须的；可以用迭代控制结构来代替它。这种技术称作尾递归，对多数的编译程序都加以了采用。

考虑下面合格快速排序的版本，它模拟了尾递归：

QUICKSORT'(A, p, r)

1  while p < r

2        do ? Partition and sort left subarray.

3             q ← PARTITION(A, p, r)

4             QUICKSORT'(A, p, q - 1)

5             p ← q + 1

a）论证QUICKSORT'(A, 1, length[A])能正确地对数组A进行排序。

b）请给出一种在含有n个元素的输入数组上QUICKSORT'的栈深度为Θ(n)的情况。

c）修改QUICKSORT'的代码，使其最坏情况下栈深度为Θ(lgn)，保持算法的O(nlgn)期望运行时间不变。

 

 

分析与解答：

a）QUICKSORT'对A[p...r]进行排序时，先PARTITION，然后对左边的子数组进行排序，接下来对右边的子数组也采取同样的操作

     0----4----3-----------2-------------------------1--------------------------------------------------------0

    相对于对待排序的数组，每次分出一部分进行排序，直到所有的部分都已经分出去了，所以能够正确地对数组A进行排序。

 

b) 栈的深度就类似于递归树的深度，当数组正序时，递归的深度为Θ(n)，栈的深度也为Θ(n)

     例如A={1, 2, ... , n}

 

c）为了使最坏情况下栈的深度为Θ(lgn),我们必须是PARTITION后左边的子数组为原来数组的一半大小，这样递归的深度最多为Θ(lgn)。

    一种可能的算法是：首先求得(A, p, r)的中位数，作为PARTITION的枢轴元素，这样可以保证左右两边的元素的个数尽可能的均衡。

    因为求中位数的过程MEDIAN的时间复杂度为Θ(n)，因此可以保证算法的期望的时间复杂度O(nlgn)不变。

    修改后的代码QUICKSORT''如下：

QUICKSORT''(A, p, r)while p < r    do ? Partition and sort left subarray.       m ← MEDIAN(A, p, r)       exchange A[m] ↔ A[r]       q ← PARTITION(A, p, r)       QUICKSORT''(A, p, q - 1)       p ← q + 1

===========================

对于c的另一种解析：

快速排序的伪代码如下：

1 QUICKSORT(A, p, r)2     if p < r3         q <- PARTITION(A, p, r)4         QUICISORT(A, p, q-1)5         QUICKSORT(A, q + 1, r)

可采用尾递归的方式减小堆栈的深度，即采用迭代控制结构替代第二次递归调用，尾递归在大多数的编译程序中都被采用。伪代码如下：

1 QUICKSORT(A, p, r)2     while p < r3         q <- PARTITION(A, p, r)4         QUICISORT(A, p, q-1)5         p <- q + 1

尽管此时平均堆栈深度已减小，但最坏情况下堆栈深度仍为θ(n)，如数组元素已有序的情况下进行快速排序。那如何减小最坏情况下的堆栈深度？
核心思想仍然是采用迭代控制结构替代递归调用。前一次的思想是执行PARTITION后，对数组的前一部分( A[p...q-1] )进行递归排序，对后一部分( A[q+1...r] )进行迭代控制运算。
假设每次执行PARTITION后，(q-1) - p + 1 : r-(q+1) +1 = a ( a > 0 )，则有

n * a ^ h = 1

=> h = - lgn / lga

• a < 1/2 => h < lgn
• a = 1/2 => h = lgn
• a > 1/2 => h > lgn

因此，执行完PARTITION后，对元素个数少的那一部分进行递归排序，而对另一部分进行迭代运算，可使堆栈深度小于lgn。

伪代码如下：

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