1
QuickSort
• Worst time: (n2)• Expected time: (nlgn)
– Constants in the expected time are small
• Sorts in place
2
QuickSort (cont)
• DIVIDE – Partition A[p..r] into two subarrays A[p..q-1] and A[q+1..r] such that each element of A[p..q-1] is A[q] each element of A[q+1..r]
• Conquer – Sort the two subarrays by recursive calls to Quicksort
• Combine – Since subarrays are sorted in place, they are already sorted
3
QuickSort (cont)
To sort entire array:QuickSort( A, 1, length(A) )
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 )
4
QuickSort (cont)
Partition( A, p, r )x A[ r ]i p – 1for j p to r-1
if A[ j ] xi i + 1Exchange( A[ i ], A[ j ] )
Exchange( A[ i+1 ], A[ r ] )return i+1
5
QuickSort (cont)
1 2 3 4 5 6 7 8
19 9 62 74 94 13 90 48p,i j r,x
1 2 3 4 5 6 7 8
19 9 62 74 94 13 90 48i p,j r,x
1 2 3 4 5 6 7 8
19 9 62 74 94 13 90 48p i j r,x
1 2 3 4 5 6 7 8
19 9 62 74 94 13 90 48p i j r,x
6
QuickSort (cont)1 2 3 4 5 6 7 8
19 9 62 74 94 13 90 48p i j r,x
1 2 3 4 5 6 7 8
19 9 62 74 94 13 90 48p i j r,x
1 2 3 4 5 6 7 8
19 9 13 74 94 62 90 48p i j r,x
1 2 3 4 5 6 7 8
19 9 13 48 94 62 90 74p i r
Return i+1which is 4
7
Performance of QuickSort
• Partition function’s running time - (n)• Running time of QuickSort depends on the
balance of the partitions– If balanced, QuickSort is asymptotically as fast as
MergeSort– If unbalanced, it is asymptotically as bad as
Insertion Sort
8
Performance of QuickSort (cont)
• Worst-case Partitioning– Partitions always of size n-1 and 0– Occurs when array is already sorted– Recurrence for the running time:
)(
)()1(
)()0()1()(
2n
nnT
nTnTnT
9
Performance of QuickSort (cont)cn
c(n-1)
c(n-2)
...
n
cn
c(n-1)
c(n-2)
c
Total: (n2)
)(2
)1( 2
11
nnn
iccin
i
n
i
10
Performance of QuickSort (cont)
• Best-case Partitioning– Partitions always of size n/2 and n/2-1– The recurrence for the running time:
)lg()(
)()(2)( 2
nnnT
nTnT n
Case 2 of Master Method
11
Performance of QuickSort (cont)
• Balanced Partitioning– Average-case is closer to best-case– Any split of constant proportionality (say 99 to
1) will have a running time of (nlgn)• The recurrence will be
• Because it yields a recursion tree of depth (lgn), where cost at each level is (n)
• See page 151 (new book) for picture– Or next slide
cnnTnTnT )()()( 1001
10099
12
Performance of QuickSort (cont)
c(n/100) c(99n/100)
cn
c(n/10000) c(99n/10000) c(99n/10000) c(9801n/10000)
T(1)
T(1)
T(1)T(1)
Total: (nlgn)
log100ncn
cn
cn
cn
cnlog100/99n
13
Performance of QuickSort (cont)
• Intuition for the average case– The behavior depends on the relative ordering of
the values• Not the values themselves
– We will assume (for now) that all permutations are equally likely
– Some splits will be balanced, and some will be unbalanced
14
Performance of QuickSort (cont)
– In a recursion tree for an average-case, the “good” and “bad” splits are distributed randomly throughout the tree
– For our example, suppose• Bad splits and good splits alternate• Good splits are best-case splits• Bad splits are worst-case splits• Boundary case (subarray size 0) has cost of 1
15
Performance of QuickSort (cont)
– The (n-1) cost of the bad split can be absorbed into the (n) cost of the good split, and the resulting split is good
– Thus the running time is (nlgn), but with a slightly larger constant
n
0 n - 1
(n-1)/2(n-1)/2-1
(n)n
(n-1)/2(n-1)/2
(n)
16
Randomized QuickSort
• How do we increase the chance that all permutations are equally likely?– Random Sampling
• Don’t always use last element in subarray• Swap it with a randomly chosen element from the
subarray– Pivot now is equally likely to be any of the r – p + 1
elements• We can now expect the split to be reasonably well-
balanced on average
17
Randomized QuickSort (cont)
Randomized-Partition( A, p, r )
1. i Random( p, r )
2. Exchange( A[ r ], A[ i ] )
3. return Partition( A, p, r )
Note that Partition( ) is same as before
18
Randomized QuickSort (cont)
Randomized-QuickSort( A, p, r )
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 )
19
Analysis of QuickSort
• A more rigorous analysis• Begin with worst-case
– We intuited that worst-case running time is (n2)– Use substitution method to show this is true
)())1()((max)(10
nqnTqTnTnq
20
Analysis of QuickSort (cont)
– Guess: (n2)– Show: for some c > 0– Substitute: 2)( cnnT
)()(
)()12()(
)())1((max
)())1((max)(
2
2
2
22
10
22
10
nnT
cn
nnccnnT
nqnqc
nqnccqnT
nq
nq
q2+(n-q-1)2 is max at endpoints of range. Therefore it is (n-1)2 = n2 – 2n +1
21
Analysis of QuickSort (cont)
– Problem 7.4-1 has you show that
– Thus the worst-case running time of QuickSort is (n2)
)(
)())1()((max)(
2
10
n
nqnTqTnTnq
22
Analysis of QuickSort (cont)
• We need to show that the upper-bound on expected running time is (nlgn)
• We’ve already shown that the best-case running time is (nlgn)
• Combined, these will give an expected running time of (nlgn)
23
Analysis of QuickSort (cont)• Expected Running Time
– Work done is dominated by Partition– Each time a pivot is selected, this element is
never included in subsequent calls to QuickSort• And the pivot is in its correct place in the array
– Therefore, at most n calls to Partition will be made
• Each call to Partition involves (1) work plus the amount of work done in the for loop
• Count the total number of times line 4 is executed, we can bound the amount of time spent in the for loop
Line 4: if A[j] x
Top Related