Chapter 7

Quicksort

Outlines: Quicksort

 Quicksort: Advantages and Disadvantages

 Quicksort:
 Quicksort Function
 In-Place Partition Function
 Choice Of Pivot
 Rightmost or Leftmost
 Randomly
 Median-of-Three Rule
 Partitioning using Additional Array
 Runtime of Quicksort (Worst, Best, Average)

1
 Quicksort
 Quicksort pros:
 Sorts in place
 Sorts O(n lg n) in the average case
 Very efficient in practice

 Quicksort cons:
 Sorts O(n2) in the worst case
 not stable
 does not preserve the relative order of elements with equal
keys

 But in practice, it’s quick

 And the worst case doesn’t happen often … sorted

Quicksort

 Another divide-and-conquer algorithm:

 Divide: A[p…r] is partitioned (rearranged) into two
nonempty subarrays A[p…q-1] and A[q+1…r] such that each
element of A[p…q-1] is less than or equal to each element of
A[q+1…r]. Index q is computed here, called pivot.

 Conquer: two subarrays are sorted by recursive calls to

quicksort.

 Combine: unlike merge sort, no work needed since the

subarrays are sorted in place already.

2
 Quicksort

 The basic algorithm to sort an array A consists of the

following four easy steps:
 If the number of elements in A is 0 or 1, then return
 Pick any element v in A. This is called the pivot
 Partition A-{v} (the remaining elements in A) into two
disjoint groups:
 A1 = {x  A-{v} | x ≤ v}, and
 A2 = {x  A-{v} | x ≥ v}
 return
 { quicksort(A1) followed by v followed by quicksort(A2) }

Quicksort
 Small instance has n ≤ 1
 Every small instance is a sorted instance
 To sort a large instance:
 select a pivot element from out of the n
elements
 Partition the n elements into 3 groups left, middle
and right
 The middle group contains only the pivot
element
 All elements in the left group are ≤ pivot
 All elements in the right group are ≥ pivot
 Sort left and right groups recursively
 Answer is sorted left group, followed by middle
group followed by sorted right group
6

3
 Example

6 2 8 5 11 10 4 1 9 7 3

Use 6 as the pivot

2 5 4 1 3 6 7 9 10 11 8

Sort left and right groups recursively

7

Quicksort Code
Quicksort(A, p, r)
{
if (p < r)
{
q = Partition(A, p, r)
Quicksort(A, p, q-1)
Quicksort(A, q+1, r)
}
}

 Initial call is Quicksort(A, 1, n), where n is the

length of A
8

4
 Partition

 Clearly, all the action takes place in the

partition() function
 Rearranges the subarray in place
 End result:
 Two subarrays
 All values in first subarray  all values in second
 Returns the index of the “pivot” element
separating the two subarrays

In-Place Partition Code

Partition(A, p, r)
{
x = A[r] // x is pivot
i = p - 1
for j = p to r – 1
{
do if A[j] <= x
then
{
i = i + 1
exchange A[i]  A[j]
}
}
exchange A[i+1]  A[r]
return i+1
}
partition() runs in O(n) time

10

5
 In-Place Partition Example
A = {2, 8, 7, 1, 3, 5, 6, 4}
i pj r pi j r
2 8 7 1 3 5 6 4 2 8 7 1 3 5 6 4
pi j r pi j r
2 8 7 1 3 5 6 4 2 8 7 1 3 5 6 4
p i j r p i j r
2 1 7 8 3 5 6 4 2 11 33 8 7 5 6 4
p i j r p i r
2 11 33 8 7 5 6 4 2 11 33 8 7 5 6 4
p i r
2 11 33 4 7 5 6 8
11

Partition Example Explanation

 Red shaded elements are in the first partition

with values  x (pivot)

 Gray shaded elements are in the second

partition with values  x (pivot)

 The unshaded elements have no yet been put

in one of the first two partitions

 The final white element is the pivot

12

6
 Choice Of Pivot

 Pivot is rightmost element in list that is to be sorted

 When sorting A[6:20], use A[20] as the pivot

 Textbook implementation does this

 Randomly select one of the elements to be sorted

as the pivot
 When sorting A[6:20], generate a random
number r in the range [6, 20]
 Use A[r] as the pivot

13

Choice Of Pivot

 Median-of-Three rule - from the leftmost, middle, and

rightmost elements of the list to be sorted, select the one
with median key as the pivot
 When sorting A[6:20], examine A[6], A[13] ((6+20)/2),
and A[20]
 Select the element with median (i.e., middle) key

 If A[6].key = 30, A[13].key = 2, and A[20].key = 10,

A[20] becomes the pivot

 If A[6].key = 3, A[13].key = 2, and A[20].key = 10,

A[6] becomes the pivot

14

7
 Choice Of Pivot
 If A[6].key = 30, A[13].key = 25, and
A[20].key = 10, A[13] becomes the pivot

 When the pivot is picked at random or when the

median-of-three rule is used, we can use the
quicksort code of the textbook provided we first
swap the rightmost element and the chosen pivot.
swap

pivot
15

Partitioning Example Using

Additional Array
 Sort A = [6, 2, 8, 5, 11, 10, 4, 1, 9, 7, 3].

 Leftmost element (6) is the pivot

 When another array B is available:

 Scan A from left to right (omit the pivot in this scan),

placing elements  pivot at the left end of B and the
remaining elements at the right end of B

 The pivot is placed at the remaining position of the B

16

8
 Partitioning Example Using
Additional Array

A 6 2 8 5 11 10 4 1 9 7 3

B 2 5 4 1 3 6 7 9 10 11 8

Sort left and right groups recursively.

17

Runtime of Quicksort

 Worst case:
 every time nothing to move
 pivot = left (right) end of subarray
 (n2)

0123456789

0 123456789
n
89

8 9

18

9
 Worst Case Partitioning

19

Worst Case Partitioning

 The running time of quicksort depends on whether
the partitioning is balanced or not.

 (n) time to partition an array of n elements

 Let T(n) be the time needed to sort n elements

 T(0) = T(1) = c, where c is a constant

 When n > 1,
 T(n) = T(|left|) + T(|right|) + (n)

 T(n) is maximum (worst-case) when either |left| = 0

or |right| = 0 following each partitioning
20

10
 Worst Case Partitioning
 Worst-Case Performance (unbalanced):

 T(n) = T(1) + T(n-1) + (n)

 partitioning takes (n)
 = 2 + 3 + 4 + …+ n-1 + n + n =
 = k = 2 to n(k) + n = ( k = 2 to nk) + n = (n2)

 This occurs when

 the input is completely sorted
 or when
 the pivot is always the smallest (or largest) element

21

Best Case Partition

 When the partitioning procedure produces two

regions of size n/2, we get the a balanced partition
with best case performance:
 T(n) = 2T(n/2) + (n) = (n lg n)

 Average complexity is also (n lg n)

22

11
 Best Case Partitioning

23

Average Case

 Assuming random input, average-case running time

is much closer to (n lg n) than (n2)

 First, a more intuitive explanation/example:

 Suppose that partition() always produces a 1-to-9
proportional split. This looks quite unbalanced!
 The recurrence is thus:

T(n) = T(n/10) + T(9n/10) + (n) = (n lg n)!

 How deep will the recursion go?

24

12
 Average Case
T (n)  T ( n /10)  T (9n /10)  (n)  (n log n)!

For a split of proportionality , where 0½, the minimum depth

of the tree is - lg n / lg  & the maximum depth is - lg n / lg(1-).
log2n = log10n/log102
25

Average Case

 Intuitively, a real-life run of quicksort will produce a

mix of “unlucky” and “lucky” splits

 Randomly distributed among the recursion tree

 Pretend for intuition that they alternate between

worst-case (n-1:1) and best-case (n/2:n/2)

26

13
 Average Case
 What happens if we unlucky-split root node, then lucky-split the
resulting size (n-1) node?
 We end up with three subarrays, size

 1, (n-1)/2, (n-1)/2

n (n)

1 n-1 (n 1)

(n-1)/2 (n-1)/2

27

Intuition for the Average Case

 Suppose, we alternate lucky and unlucky cases to get an

average behavior

L (n)  2U (n / 2)  (n) lucky

U (n)  L(n  1)  (n) unlucky
we consequently get
L (n)  2( L (n / 2  1)  ( n / 2))  (n)
 2 L (n / 2  1)   (n)
 ( n log n)

The combination of lucky and unlucky splits would result in

T(n) = (n lg n), but with slightly larger constant hidden by
the -notation.
28

14
 Review: Analyzing Quicksort

 What will be the worst case for the algorithm?

 Partition is always unbalanced
 What will be the best case for the algorithm?
 Partition is balanced
 Which is more likely?
 The latter, by far, except...
 Will any particular input shows the worst case?
 Yes: Already-sorted input

29

15