Quick Sort

Quicksort
QuickSort
In this topic we will look at quicksort:

– The idea behind the algorithm
– The run time and worst-case scenario
– Strategy for avoiding the worst-case: median-of-three
– Implementing quicksort in place
– Examples
Quicksort
2
Strategy
We have seen two Θ(n ln(n)) sorting algorithms:

– Heap sort which allows in-place sorting, and
– Merge sort which is faster but requires more memory
We will now look at a recursive algorithm which may be done almost

in place but which is faster than heap sort
– Use an object in the array (a pivot) to divide the two
– Average case: Θ(n ln(n)) time and Θ(ln(n)) memory
– Worst case: Θ(n2) time and Θ(n) memory
We will look at strategies for avoiding the worst case

Quicksort
3
Quicksort
Merge sort splits the array sub-lists and sorts them
The larger problem is split into two sub-problems based on location

in the array
Consider the following alternative:

– Chose an object in the array and partition the remaining objects into two
groups relative to the chosen entry
Quicksort
4
Quicksort
For example, given

80 38 95 84 66 10 79 44 26 87 96 12 43 81 3
we can select the middle entry, 44, and sort the remaining entries
into two groups, those less than 44 and those greater than 44:
38 10 26 12 43 3 44 80 95 84 66 79 87 96 81
Notice that 44 is now in the correct location if the list was sorted
– Proceed by applying the algorithm to the first six and last eight entries
Quicksort
5
Run-time analysis
Like merge sort, we can either:

– Apply insertion sort if the size of the sub-list is sufficiently small, or
– Sort the sub-lists using quicksort
In the best case, the list will be split into two approximately equal
sub-lists, and thus, the run time could be very similar to that of
merge sort: Θ(n ln(n))
What happens if we don’t get that lucky?

Quicksort
6
7.6.2 Worst-case scenario
Suppose we choose the first element as our pivot and we try

ordering a sorted list:
80 38 95 84 66 10 79 2 26 87 96 12 43 81 3
Using 2, we partition into

2 80 38 95 84 66 10 79 26 87 96 12 43 81 3
We still have to sort a list of size n – 1
The run time is T(n) = T(n – 1) + Θ(n) = Θ(n2)

– Thus, the run time drops from n ln(n) to n2
Quicksort
7
7.6.2 Worst-case scenario
Our goal is to choose the median element in the list as our pivot:
80 38 95 84 66 10 79 2 26 87 96 12 43 81 3
Unfortunately, it’s difficult to find
Alternate strategy: take the median of a subset of entries

– For example, take the median of the first, middle, and last entries
Quicksort
8
7.6.3 Median-of-three
It is difficult to find the median so consider another strategy:

– Choose the median of the first, middle, and last entries in the list
This will usually give a better approximation of the actual median

Quicksort
9
Sorting the elements based on 44 results in two sub-lists, each of

which must be sorted (again, using quicksort)
Select the 26 to partition the first sub-list:
Select 81 to partition the second sub-list:

Quicksort
10
If we choose a random pivot, this will, on average, divide a set of n

items into two sets of size 1/4 n and 3/4 n
– 90 % of the time the width will have a ratio 1:19 or better
Choosing the median-of-three, this will, on average, divide the n

items into two sets of size 5/16 n and 11/16 n
– Median-of-three helps speed the algorithm
– This requires order statistics: 3 (1 − x )
2
1 3x 2
2
5
2 ∫ x ⋅ ( 6 x (1 − x ) ) dx = =0.3125 3! x (1 − x )
0
16
– Ratio 1:2.2 on average
– 90 % of the time, the width will have a
ratio of 1:6.388 or better
Quicksort
11
Recall that merge sort always divides a list into two equal halves:
1
ln  
2
– The median-of-three will require   ≈ 1.8499 or 85 % more recursive
steps  11 
ln  
 16 
1
ln  
– A single random pivot will require  2  ≈ 2.4094 or 141 % more
recursive steps 3
ln  
4
Quicksort
12
Question: what is the affect on run time?

– Surprisingly, not so much  1  3 
Trandom pivot ( n ) = T   n   + T   n   + n
– Here we see the ratios of the 4  4 
recurrence relations for large
 5    11  
values of n T (n) = T
median of 3  n +T
  n +n

  16     16 
 1   1 
Tmedian ( n ) = T   n   + T   n   + n
Trandom pivot ( n ) 2  2 
Tmedian ( n )
Tmedian of 3 ( n )
Tmedian ( n )
Quicksort
13
7.6.4 Implementation
If we choose to allocate memory for an additional array, we can

implement the partitioning by copying elements either to the front or
the back of the additional array
Finally, we would place the pivot into the resulting hole

Quicksort
14
For example, consider the following:

– 57 is the median-of-three
– we go through the remaining elements, assigning them either to the
front or the back of the second array
Quicksort
15
Once we are finished, we copy the median-of-three, 57, into the

resulting hole
Quicksort
16
Note, however, we can do a better job with merge sort, it always

divides the numbers being sorted into two equal or near-equal
arrays
Can we implement quicksort in place?

Quicksort
17
First, we have already examined the first, middle, and last entries
and chosen the median of these to be the pivot
In addition, we can:
– move the smallest entry to the first entry
– move the largest entry to the middle entry
Quicksort
18
Next, recall that our goal is to partition all remaining elements based
on whether they are smaller than or greater than the pivot
We will find two entries:

– One larger than the pivot (staring from the front)
– One smaller than the pivot (starting from the back)
which are out of order and then swap them
Quicksort
19
Continue doing so until the appropriate entries you find are actually
in order
The index to the larger entry we found would be the first large entry
in the list (as seen from the left)
Therefore, we could move this entry into the last entry of the list
We can fill this spot with the pivot
Quicksort
20
Implementation
The implementation is straight-forward

def quicksort(array, first, last)
if last - first <= N
insertion_sort( array, first, last )
else
pivot = find_pivot( array, first, last )
low = find_next( pivot, array, first + 1 )
high = find_previous( pivot, array, last - 2 )
while low < high

swap(array[low],array[high])
low = find_next( pivot, array, low + 1 )
high = find_previous( pivot, array, high - 1 )
array[last – 1] = array[low]
array[low] = pivot
quicksort( array, first, low )
quicksort( array, high, last )
Quicksort
21
Quicksort example
Consider the following unsorted array of 25 entries

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 77 49 35 61 48 73 23 95 3 89 37 57 99 17 32 94 28 15 55 7 51 88 97 62
We will call insertion sort if the list being sorted of size N = 6 or less
Quicksort
22
7.6.5 Quicksort example
We call quicksort( array, 0, 25 )

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 77 49 35 61 48 73 23 95 3 89 37 57 99 17 32 94 28 15 55 7 51 88 97 62
quicksort( array, 0, 25 )
Quicksort
23
We are calling quicksort( array, 0, 25 )

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 77 49 35 61 48 73 23 95 3 89 37 57 99 17 32 94 28 15 55 7 51 88 97 62
First, 25 – 0 > 6, so find the midpoint and the pivot

midpoint = (0 + 25)/2; // == 12
Quicksort
24

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 77 49 35 61 48 73 23 95 3 89 37 62 99 17 32 94 28 15 55 7 51 88 97

midpoint = (0 + 25)/2; // == 12
pivot = 57;
Quicksort
25

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 77 49 35 61 48 73 23 95 3 89 37 62 99 17 32 94 28 15 55 7 51 88 97
Starting from the front and back:

– Find the next element greater than the pivot
– The last element less than the pivot
pivot = 57;
Quicksort
26

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 77 49 35 61 48 73 23 95 3 89 37 62 99 17 32 94 28 15 55 7 51 88 97
Searching forward and backward:

low = 1;
high = 21;
pivot = 57;
Quicksort
27

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 61 48 73 23 95 3 89 37 62 99 17 32 94 28 15 55 7 77 88 97

low = 1;
high = 21;
Swap them
pivot = 57;
Quicksort
28

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 61 48 73 23 95 3 89 37 62 99 17 32 94 28 15 55 7 77 88 97
Continue searching
low = 4;
high = 20;
pivot = 57;
Quicksort
29

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 73 23 95 3 89 37 62 99 17 32 94 28 15 55 61 77 88 97
Continue searching
low = 4;
high = 20;
Swap them
pivot = 57;
Quicksort
30

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 73 23 95 3 89 37 62 99 17 32 94 28 15 55 61 77 88 97
Continue searching
low = 6;
high = 19;
pivot = 57;
Quicksort
31

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 55 23 95 3 89 37 62 99 17 32 94 28 15 73 61 77 88 97
Continue searching
low = 6;
high = 19;
Swap them
pivot = 57;
Quicksort
32

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 55 23 95 3 89 37 62 99 17 32 94 28 15 73 61 77 88 97
Continue searching
low = 8;
high = 18;
pivot = 57;
Quicksort
33

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 55 23 15 3 89 37 62 99 17 32 94 28 95 73 61 77 88 97
Continue searching
low = 8;
high = 18;
Swap them
pivot = 57;
Quicksort
34

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 55 23 15 3 89 37 62 99 17 32 94 28 95 73 61 77 88 97
Continue searching
low = 10;
high = 17;
pivot = 57;
Quicksort
35

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 55 23 15 3 28 37 62 99 17 32 94 89 95 73 61 77 88 97
Continue searching
low = 10;
high = 17;
Swap them
pivot = 57;
Quicksort
36

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 55 23 15 3 28 37 62 99 17 32 94 89 95 73 61 77 88 97
Continue searching
low = 12;
high = 15;
pivot = 57;
Quicksort
37

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 55 23 15 3 28 37 32 99 17 62 94 89 95 73 61 77 88 97
Continue searching
low = 12;
high = 15;
Swap them
pivot = 57;
Quicksort
38

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 55 23 15 3 28 37 32 99 17 62 94 89 95 73 61 77 88 97
Continue searching
low = 13;
high = 14;
pivot = 57;
Quicksort
39

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 55 23 15 3 28 37 32 17 99 62 94 89 95 73 61 77 88 97
Continue searching
low = 13;
high = 14;
Swap them
pivot = 57;
Quicksort
40

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 55 23 15 3 28 37 32 17 99 62 94 89 95 73 61 77 88 97
Continue searching
low = 14;
high = 13;
Now, low > high, so we stop
pivot = 57;
Quicksort
41

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 55 23 15 3 28 37 32 17 57 62 94 89 95 73 61 77 88 97 99
Continue searching
low = 14;
high = 13;
pivot = 57;
Quicksort
42

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 55 23 15 3 28 37 32 17 57 62 94 89 95 73 61 77 88 97 99
We now begin calling quicksort recursively on the first half

quicksort( array, 0, 14 );
Quicksort
43
We are executing quicksort( array, 0, 14 )

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 55 23 15 3 28 37 32 17 57 62 94 89 95 73 61 77 88 97 99

midpoint = (0 + 14)/2; // == 7
Quicksort
44

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 55 23 15 3 28 37 32 17 57 62 94 89 95 73 61 77 88 97 99

midpoint = (0 + 14)/2; // == 7
pivot = 17
Quicksort
45

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 55 23 15 3 28 37 32 57 62 94 89 95 73 61 77 88 97 99

midpoint = (0 + 14)/2; // == 7
pivot = 17;
Quicksort
46

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 55 23 15 3 28 37 32 57 62 94 89 95 73 61 77 88 97 99

pivot = 17;
Quicksort
47

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 51 49 35 7 48 55 23 15 3 28 37 32 57 62 94 89 95 73 61 77 88 97 99

low = 1;
high = 9;
pivot = 17;
Quicksort
48

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 3 49 35 7 48 55 23 15 51 28 37 32 57 62 94 89 95 73 61 77 88 97 99

low = 1;
high = 9;
Swap them
pivot = 17;
Quicksort
49

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 3 49 35 7 48 55 23 15 51 28 37 32 57 62 94 89 95 73 61 77 88 97 99

low = 2;
high = 8;
pivot = 17;
Quicksort
50

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 3 15 35 7 48 55 23 49 51 28 37 32 57 62 94 89 95 73 61 77 88 97 99

low = 2;
high = 8;
Swap them
pivot = 17;
Quicksort
51

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 3 15 35 7 48 55 23 49 51 28 37 32 57 62 94 89 95 73 61 77 88 97 99

low = 3;
high = 4;
pivot = 17;
Quicksort
52

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 3 15 7 35 48 55 23 49 51 28 37 32 57 62 94 89 95 73 61 77 88 97 99

low = 3;
high = 4;
Swap them
pivot = 17;
Quicksort
53

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 3 15 7 35 48 55 23 49 51 28 37 32 57 62 94 89 95 73 61 77 88 97 99

low = 4;
high = 3;
pivot = 17;
Quicksort
54

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 3 15 7 17 48 55 23 49 51 28 37 32 35 57 62 94 89 95 73 61 77 88 97 99
We continue calling quicksort recursively

Quicksort
55

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 3 15 7 17 48 55 23 49 51 28 37 32 35 57 62 94 89 95 73 61 77 88 97 99
Now, 4 – 0 ≤ 6, so find we call insertion sort
Quicksort
56
Insertion sort just sorts the entries from 0 to 3

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
13 3 15 7 17 48 55 23 49 51 28 37 32 35 57 62 94 89 95 73 61 77 88 97 99
insertion_sort( array, 0, 4 )
Quicksort
57

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 48 55 23 49 51 28 37 32 35 57 62 94 89 95 73 61 77 88 97 99
– This function call completes and so we exit
Quicksort
58
This call to quicksort is now also finished, so it, too, exits

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 48 55 23 49 51 28 37 32 35 57 62 94 89 95 73 61 77 88 97 99
Quicksort
59
We are back to executing quicksort( array, 0, 14 )

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 48 55 23 49 51 28 37 32 35 57 62 94 89 95 73 61 77 88 97 99
We continue calling quicksort recursively on the second half

Quicksort
60
We now are calling quicksort( array, 5, 14 )

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 48 55 23 49 51 28 37 32 35 57 62 94 89 95 73 61 77 88 97 99

midpoint = (5 + 14)/2; // == 9
Quicksort
61

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 48 55 23 49 51 28 37 32 35 57 62 94 89 95 73 61 77 88 97 99

midpoint = (5 + 14)/2; // == 9
pivot = 48
Quicksort
62

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 35 55 23 49 51 28 37 32 57 62 94 89 95 73 61 77 88 97 99

midpoint = (5 + 14)/2; // == 9
pivot = 48
Quicksort
63

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 35 55 23 49 51 28 37 32 57 62 94 89 95 73 61 77 88 97 99

pivot = 48;
Quicksort
64

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 35 55 23 49 51 28 37 32 57 62 94 89 95 73 61 77 88 97 99

low = 6;
high = 12;
pivot = 48;
Quicksort
65

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 35 32 23 49 51 28 37 55 57 62 94 89 95 73 61 77 88 97 99

low = 6;
high = 12;
Swap them
pivot = 48;
Quicksort
66

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 35 32 23 49 51 28 37 55 57 62 94 89 95 73 61 77 88 97 99
Continue searching
low = 8;
high = 11;
pivot = 48;
Quicksort
67

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 35 32 23 37 51 28 49 55 57 62 94 89 95 73 61 77 88 97 99
Continue searching
low = 8;
high = 11;
Swap them
pivot = 48;
Quicksort
68

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 35 32 23 37 51 28 49 55 57 62 94 89 95 73 61 77 88 97 99
Continue searching
low = 8;
high = 11;
pivot = 48;
Quicksort
69

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 35 32 23 37 28 51 49 55 57 62 94 89 95 73 61 77 88 97 99
Continue searching
low = 8;
high = 11;
Swap them
pivot = 48;
Quicksort
70

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 35 32 23 37 28 51 49 55 57 62 94 89 95 73 61 77 88 97 99
Continue searching
low = 8;
high = 11;
pivot = 48;
Quicksort
71

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 35 32 23 37 28 48 49 55 51 57 62 94 89 95 73 61 77 88 97 99
Continue searching
low = 8;
high = 11;
pivot = 48;
Quicksort
72

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 35 32 23 37 28 48 49 55 51 57 62 94 89 95 73 61 77 88 97 99
We now begin calling quicksort recursively on the first half

Quicksort
73

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 35 32 23 37 28 48 49 55 51 57 62 94 89 95 73 61 77 88 97 99
We now begin calling quicksort recursively

Quicksort
74

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 35 32 23 37 28 48 49 55 51 57 62 94 89 95 73 61 77 88 97 99
Quicksort
75

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 35 32 23 37 28 48 49 55 51 57 62 94 89 95 73 61 77 88 97 99
Quicksort
76

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 55 51 57 62 94 89 95 73 61 77 88 97 99
Quicksort
77

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 55 51 57 62 94 89 95 73 61 77 88 97 99
Quicksort
78

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 55 51 57 62 94 89 95 73 61 77 88 97 99

Quicksort
79

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 55 51 57 62 94 89 95 73 61 77 88 97 99
Quicksort
80

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 55 51 57 62 94 89 95 73 61 77 88 97 99

Quicksort
81

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 62 94 89 95 73 61 77 88 97 99

Quicksort
82

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 62 94 89 95 73 61 77 88 97 99

Quicksort
83

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 62 94 89 95 73 61 77 88 97 99
Quicksort
84

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 62 94 89 95 73 61 77 88 97 99
Quicksort
85

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 62 94 89 95 73 61 77 88 97 99

Quicksort
86

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 62 94 89 95 73 61 77 88 97 99

midpoint = (15 + 25)/2; // == 20

Quicksort
87

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 94 89 95 73 99 77 88 97

midpoint = (15 + 25)/2; // == 20
pivot = 62;

Quicksort
88

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 94 89 95 73 99 77 88 97

low = 16;
high = 15;
pivot = 62;

Quicksort
89

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 89 95 73 99 77 88 97 94

low = 16;
high = 15;
– Note, this is the worst-case scenario
– The pivot is the second smallest element
pivot = 62;

Quicksort
90

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 89 95 73 99 77 88 97 94
We continue calling quicksort recursively on the first half


Quicksort
91

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 89 95 73 99 77 88 97 94

Quicksort
92
Insertion sort immediately returns

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 89 95 73 99 77 88 97 94

Quicksort
93

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 89 95 73 99 77 88 97 94

Quicksort
94

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 89 95 73 99 77 88 97 94


Quicksort
95
We are now calling quicksort( array, 17, 25 )

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 89 95 73 99 77 88 97 94

midpoint = (17 + 25)/2; // == 21

Quicksort
96

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 89 95 73 99 77 88 97 94

midpoint = (17 + 25)/2; // == 21

Quicksort
97

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 89 95 73 99 77 88 97 94

midpoint = (17 + 25)/2; // == 21
pivot = 89

Quicksort
98

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 77 95 73 99 94 88 97

midpoint = (17 + 25)/2; // == 21
pivot = 89

Quicksort
99

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 77 95 73 99 94 88 97

low = 18;
high = 22;
pivot = 89;

Quicksort
100

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 77 88 73 99 94 95 97

low = 18;
high = 22;
Swap them
pivot = 89;

Quicksort
101

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 77 88 73 99 94 95 97

low = 20;
high = 19;
pivot = 89;

Quicksort
102

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 77 88 73 89 94 95 97 99

low = 20;
high = 19;
pivot = 89;

Quicksort
103

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 77 88 73 89 94 95 97 99
We start by calling quicksort recursively on the first half


Quicksort
104
We are now executing quicksort( array, 17, 20 )

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 77 88 73 89 94 95 97 99

Quicksort
105

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 77 88 73 89 94 95 97 99

Quicksort
106

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 73 77 88 89 94 95 97 99

Quicksort
107

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 73 77 88 89 94 95 97 99

Quicksort
108

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 73 77 88 89 94 95 97 99

Quicksort
109

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 73 77 88 89 94 95 97 99
We continue by calling quicksort on the second half


Quicksort
110

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 73 77 88 89 94 95 97 99

Quicksort
111

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 73 77 88 89 94 95 97 99

Quicksort
112

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 73 77 88 89 94 95 97 99
– In this case, the sub-array was already sorted


Quicksort
113

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 73 77 88 89 94 95 97 99

Quicksort
114

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 73 77 88 89 94 95 97 99

Quicksort
115

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 73 77 88 89 94 95 97 99

Quicksort
116

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 73 77 88 89 94 95 97 99
Quicksort
117
We have now used quicksort to sort this array of 25 entries

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
3 7 13 15 17 23 28 32 35 37 48 49 51 55 57 61 62 73 77 88 89 94 95 97 99

Quick Sort

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Quick Sort

Uploaded by

Copyright:

Available Formats

Quicksort

In this topic we will look at quicksort:

We have seen two Θ(n ln(n)) sorting algorithms:

We will now look at a recursive algorithm which may be done almost

We will look at strategies for avoiding the worst case

Merge sort splits the array sub-lists and sorts them

The larger problem is split into two sub-problems based on location

Consider the following alternative:

For example, given

Like merge sort, we can either:

What happens if we don’t get that lucky?

Suppose we choose the first element as our pivot and we try

Using 2, we partition into

We still have to sort a list of size n – 1

The run time is T(n) = T(n – 1) + Θ(n) = Θ(n2)

Unfortunately, it’s difficult to find

Alternate strategy: take the median of a subset of entries

It is difficult to find the median so consider another strategy:

This will usually give a better approximation of the actual median

Sorting the elements based on 44 results in two sub-lists, each of

Select the 26 to partition the first sub-list:

Select 81 to partition the second sub-list:

If we choose a random pivot, this will, on average, divide a set of n

Choosing the median-of-three, this will, on average, divide the n

Question: what is the affect on run time?

If we choose to allocate memory for an additional array, we can

Finally, we would place the pivot into the resulting hole

For example, consider the following:

Once we are finished, we copy the median-of-three, 57, into the

Note, however, we can do a better job with merge sort, it always

Can we implement quicksort in place?

We will find two entries:

The implementation is straight-forward

while low < high

Consider the following unsorted array of 25 entries

We call quicksort( array, 0, 25 )

We are calling quicksort( array, 0, 25 )

First, 25 – 0 > 6, so find the midpoint and the pivot

We are calling quicksort( array, 0, 25 )

First, 25 – 0 > 6, so find the midpoint and the pivot

We are calling quicksort( array, 0, 25 )

Starting from the front and back:

We are calling quicksort( array, 0, 25 )

Searching forward and backward:

We are calling quicksort( array, 0, 25 )

Searching forward and backward:

We are calling quicksort( array, 0, 25 )

We are calling quicksort( array, 0, 25 )

We are calling quicksort( array, 0, 25 )

We are calling quicksort( array, 0, 25 )

We are calling quicksort( array, 0, 25 )

We are calling quicksort( array, 0, 25 )

We are calling quicksort( array, 0, 25 )

We are calling quicksort( array, 0, 25 )

We are calling quicksort( array, 0, 25 )

We are calling quicksort( array, 0, 25 )

We are calling quicksort( array, 0, 25 )

We are calling quicksort( array, 0, 25 )

We are calling quicksort( array, 0, 25 )

We are calling quicksort( array, 0, 25 )

We are calling quicksort( array, 0, 25 )

We now begin calling quicksort recursively on the first half

We are executing quicksort( array, 0, 14 )

First, 14 – 0 > 6, so find the midpoint and the pivot