Quicksort Algorithm

1. Quicksort Algorithm CS 583 Analysis of Algorithms CS583 Fall'06: Quicksort

2. Outline • Quicksort Algorithm • Performance Analysis • Worst-case partitioning • Best-case partitioning • Balanced partitioning • Randomized Quicksort • Worst-case analysis • Expected running time • Self-Testing • 7.1-1, 7.1-2, 7.2-3, 7.4-2 CS583 Fall'06: Quicksort

3. Quicksort Algorithm • Quicksort is a sorting algorithm with worst-case running time of (n2). • Often the best practical choice because it is very efficient on the average: O(n lg n) in a randomized algorithm. • Sorts in place. • Used divide-and-conquer approach: • Divide: Partition A[p..r] to A[p..q-1] and A[q+1..r] so that any • e1 <= A[q] and e2 >= A[q], where • e1  A[p..q-1], e2  A[q+1..r]. • Conquer: Sort A[p..q-1] and A[q+1..r] by recursive calls to quicksort. • Combine: Subarrays are sorted in place, hence A[p..r] is sorted. CS583 Fall'06: Quicksort

4. Quicksort: Partitioning i p,j r 7 4 6 3 5 i p j r 74 6 3 5 p,i j r 47 6 3 5 p,i j r 47 635 p i j r 4 36 75 p i j r 4 357 6 CS583 Fall'06: Quicksort

5. Quicksort: Pseudocode Quicksort(A, p, r) 1 if p<r 2 q = Partition(A,p,r) 3 Quicksort(A,p,q-1) 4 Quicksort(A,q+1,r) Partition(A, p, r) 1 x = A[r] 2 i = p-1 3 for j = p to r-1 4 if A[j] < x 5 i = i+1 6 <exchange A[i] with A[j]> 7 <exchange A[i+1] with A[r]> 8 return i+1 CS583 Fall'06: Quicksort

6. Quicksort: Correctness • As the procedure runs, the array is partitioned into four regions, which can be considered a loop invariant: • p <= k <= i: A[k] < x • i+1 <= k <= j-1: A[k] >= x • k=r: A[k] = x • j <= k <= r-1: undetermined • We need to show that this invariant is true: • Initialization: only 3 and 4 are relevant and they are true. • Maintenance: • A[j] > x: i does not change and a greater than x value is part of [i+1,j-1] • A[j] <= x: [p, i] is expanded with one legitimate element as well as [i+1,j-1] • Termination: j=r: all three regions are preserved. CS583 Fall'06: Quicksort

7. Partition: Analysis • At lines 7-8 the pivot is moved to the correct place and its index is returned. • To calculate the running time of Partition, assume n=p-r+1. • The loop 3 is executed n-1 times with steps 4-6 taking constant time (1). • Steps 7-8 take constant time as well. • Hence the running time of Partition is (n). CS583 Fall'06: Quicksort

8. Quicksort: Performance • The running time of quicksort depends on whether partitioning is balanced or unbalanced. • If it is balanced, the algorithm runs as fast as heapsort. • Otherwise, it can run asymptotically as slowly as insertion sort. • Worst-case scenario occurs when partitioning routine produces one subproblem with (n-1) elements and one with 0 elements. • T(n) = T(n-1) + T(0) + (n) = T(n-1) + (n) • Intuitively, T(n) = n + (n-1) + ... + 1 = (n+1)/2 * n = (n^2) • This scenario occurs when the array is already sorted. CS583 Fall'06: Quicksort

9. Quicksort: Performance (cont.) • The best-case partitioning is the most even split in which each subproblem has no more than n/2 elements. The recurrence is: • T(n) <= 2T(n/2) + (n)  • According to the master theorem's case 2, the above recurrence has the solution (n lg n). • The average-case running time of quicksort is much closer to the best case than to the worst case. • The key to understanding this is to understand how the balance of partitioning is reflected on the recurrence. CS583 Fall'06: Quicksort

10. Quicksort: Balanced Partitioning • The average-case running time of quicksort is much closer to the best case than to the worst case. • For example, assume the partitioning algorithm always produces 9:1 splitting ratio, which appears unbalanced. We have:  • T(n) <= T(9n/10) + T(n/10) + c n • The recursion tree shows that that the cost at each level is cn until the boundary level log10n = (lgn), and then levels have cost less than cn. The recursion stops at depth log10/9(n) = (lg n). • In fact, any split of constant proportionality yields a recursion tree of depth (lg n), where the cost at each level is c n. CS583 Fall'06: Quicksort

11. Quicksort: Average Case • Make an assumption that all permutations of the input numbers are equally likely. • When we run quicksort on a random array, it is unlikely that the partitioning always happens in the same way on each level. • We expect splits to be balanced and unbalanced. • In the average case, Partition produces a mix of "good" and "bad" splits, that are distributed randomly across the recursion tree. • For the sake of intuition assume that the best split follows the worst split.  • Note that, this achieves in 2 steps what the best partitioning can achieve in one step. • Intuitively, the (n-1) cost of extra split can be absorbed by (n) cost.  CS583 Fall'06: Quicksort

12. Randomized Quicksort In the randomized version of the quicksort we simply pick a pivot element randomly: Randomized-Partition(A,p,r) 1 i = Random(p, r) // pick a random number in [p,r] 2 <swap A[r] with A[i]> 3 return Partition(A,p,r) Randomized-Quicksort 1 if p<r 2 q = Randomized-Partition(A,p,r) 3 Randomized-Quicksort(A,p,q-1) 4 Randomized-Quicksort(A,q+1,r) CS583 Fall'06: Quicksort

13. Expected Running Time • The running time of quicksort is dominated by the time spent in Partition. • Note that there can be at most n calls to Partition since once the pivot element is selected it does not participate in future calls to Partition. • One call to Partition takes O(1) time plus the time proportional to the number of iterations in for loop 3-6. • Each iteration involves comparison at line 4, so we need to count the total number of times the line 4 is executed. CS583 Fall'06: Quicksort

14. Expected Running Time (cont.) Lemma 7.1. Let X be the number of comparisons performed in line 4. Then the running time of quicksort is O(n+X). Proof.There are n calls to partition. Each call does constant amount of work, then executes the for loop some number of times. Each such iteration executes line 4.  Hence we need to compute X. Rename element in A as sorted z_1, ... , z_n. Also, define the set Zij = {z_i, ... , z_j} to be the set of elements between z_i and z_j. Note that, the elements are compared only to the pivot element at each call of the partition and after the call are never compared o any other element. CS583 Fall'06: Quicksort

15. Expected Running Time (cont.) Define the indicator random variable: X_ij = I{z_i is compared to z_j} (=1 if yes, = 0 otherwise) Since each pair of two numbers is compared at most once, we have: X = i=1,n-1(j=i+1,n(X_ij)) Taking expectations of both sides we have: E[X] = E[i=1,n-1(j=i+1,n(X_ij))] = i=1,n-1(j=i+1,n(E(X_ij))) = i=1,n-1(j=i+1,n(Pr{z_i is compared to z_j})) CS583 Fall'06: Quicksort

16. Expected Running Time (cont.) To calculate Pr{ z_i is compared to z_j }, observe the following: 1) When a pivot x is chosen with: z_i < x < z_j, z_i and z_j will not be compared. 2) When a pivot x is chosen with: x = z_i or x = z_j, z_i and z_j will be compared. 3) When a pivot x is chosen with: x < z_i or x > z_j, it does not affect the comparison event. The probability of an event = (the number of successes) / (total number of outcomes). Note that, the total number of relevant outcomes are i+j-1; see 1) and 2) above. The number of successes (z_i compared to z_j) is 2 according to rule 2 above. Hence, CS583 Fall'06: Quicksort

17. Expected Running Time (cont.) Pr{z_i is compared to z_j} = 2/(j-i+1) E[X] = i=1,n-1(j=i+1,n(2/(j-i+1))))   We use change of variables k=j-i: E[X] = i=1,n-1(k=1,n-i(2/(k+1)))  < i=1,n-1(k=1,n(2/k)))) Harmonic series: k=1,n(1/k) = ln n + O(1) * Hence: i=1,n-1(k=1,n(2/k)))) = i=1,n-1(O(lg n)) = O(n lg n) => E[X] = O(n lg n) CS583 Fall'06: Quicksort