Data Structures in Java Lecture 15: Sorting II 11/11/2015 Daniel - - PowerPoint PPT Presentation

Data Structures in Java

Lecture 15: Sorting II

11/11/2015 Daniel Bauer

1

• Another divide-and-conquer algorithm.
• Pick any pivot element v.
• Partition the array into elements
• x ≤ v and x ≥ v.
• Recursively sort the partitions, then concatenate them.

Quick Sort

51 32 21 1 34 8 64 2

2

• Another divide-and-conquer algorithm.
• Pick any pivot element v.
• Partition the array into elements
• x ≤ v and x ≥ v.
• Recursively sort the partitions, then concatenate them.

Quick Sort

51 32 21 1 34 8 64 2 21

v

2

• Another divide-and-conquer algorithm.
• Pick any pivot element v.
• Partition the array into elements
• x ≤ v and x ≥ v.
• Recursively sort the partitions, then concatenate them.

Quick Sort

51 32 21 1 34 8 64 2 21

v

1 8 2

x ≤ v

2

• Another divide-and-conquer algorithm.
• Pick any pivot element v.
• Partition the array into elements
• x ≤ v and x ≥ v.
• Recursively sort the partitions, then concatenate them.

Quick Sort

51 32 21 1 34 8 64 2 21

v

1 8 2

x ≤ v

51 32 34 64

x ≥ v

2

• Another divide-and-conquer algorithm.
• Pick any pivot element v.
• Partition the array into elements
• x ≤ v and x ≥ v.
• Recursively sort the partitions, then concatenate them.

Quick Sort

51 32 21 1 34 8 64 2 21

v

8 1 2

x ≤ v

51 64 32 34

x ≥ v

3

• Another divide-and-conquer algorithm.
• Pick any pivot element v.
• Partition the array into elements
• x ≤ v and x ≥ v.
• Recursively sort the partitions, then concatenate them.

Quick Sort

51 32 21 1 34 8 64 2 21

v

8 1 2

x ≤ v

51 64 32 34

x ≥ v

3

Quick Sort

51 32 21 1 34 8 64 2 21 1 8 2 51 32 34 64

4

Quick Sort

51 32 21 1 34 8 64 2 21 1 8 2 51 32 34 64 1 8 2 51 32 34 64

5

Quick Sort

51 32 21 1 34 8 64 2 21 1 8 2 51 32 34 64 1 8 2 51 32 34 64 32 34

6

Quick Sort

51 32 21 1 34 8 64 2 21 1 8 2 51 32 34 64 1 8 2 51 32 34 64 32 34

6

Quick Sort

51 32 21 1 34 8 64 2 21 1 8 2 51 32 34 64 1 8 2 51 64 32 34

7

Quick Sort

51 32 21 1 34 8 64 2 21 1 8 2 51 32 34 64 1 8 2 51 64 32 34

7

Quick Sort

51 32 21 1 34 8 64 2 21 1 8 2 51 32 34 64 1 8 2 51 64 32 34

7

51 32 21 1 34 8 64 2 21 8 1 2 51 64 32 34

Quick Sort

8

51 32 21 1 34 8 64 2 21 8 1 2 51 64 32 34

Quick Sort

8

Quick Sort

32 34 51 64 1 2 8 21

• How do we partition the array efficiently (in place)?
• How do we pick a pivot element?
• Running time performance on quick sort 


depends on our choice.

• Bad choice leads to running time.

9

Partitioning the Array

• We don’t want to use any extra space. Need to

partition the array in place.

• Use swaps to push all elements x ≤ v to the left and

elements x ≥ v to the right.

51 32 21 1 34 8 64 2

10

Partitioning the Array

• We don’t want to use any extra space. Need to

partition the array in place.

• Use swaps to push all elements x ≤ v to the left and

elements x ≥ v to the right.

51 32 21 1 34 8 64 2

Move the pivot to the end.

10

Partitioning the Array

51 1 21 32 34 8 64 2

i j

• Move i right until we find an element array[i] ≥ v
• Move j left until we find an element array[j] ≤ v.
• if i ≥ j break
• Swap array[i] and array[j].
• While True:

11

Partitioning the Array

51 1 21 32 34 8 64 2

i j

• Move i right until we find an element array[i] ≥ v
• Move j left until we find an element array[j] ≤ v.
• if i ≥ j break
• Swap array[i] and array[j].
• While True:

11

Partitioning the Array

51 1 21 32 34 8 64 2

i j

• Move i right until we find an element array[i] ≥ v
• Move j left until we find an element array[j] ≤ v.
• if i ≥ j break
• Swap array[i] and array[j].
• While True:

11

Partitioning the Array

51 1 21 32 34 8 64 2

i j

• Move i right until we find an element array[i] ≥ v
• Move j left until we find an element array[j] ≤ v.
• if i ≥ j break
• Swap array[i] and array[j].
• While True:

11

Partitioning the Array

51 1 21 32 34 8 64 2

i j

• Move i right until we find an element array[i] ≥ v
• Move j left until we find an element array[j] ≤ v.
• if i ≥ j break
• Swap array[i] and array[j].
• While True:

11

Partitioning the Array

51 1 21 32 34 8 64 2

i j

• Move i right until we find an element array[i] ≥ v
• Move j left until we find an element array[j] ≤ v.
• if i ≥ j break
• Swap array[i] and array[j].
• While True:

11

Partitioning the Array

51 1 21 32 34 8 64 2

i j

• Move i right until we find an element array[i] ≥ v
• Move j left until we find an element array[j] ≤ v.
• if i ≥ j break
• Swap array[i] and array[j].
• While True:

11

Partitioning the Array

51 1 21 32 34 8 64 2

i j

• Move i right until we find an element array[i] ≥ v
• Move j left until we find an element array[j] ≤ v.
• if i ≥ j break
• Swap array[i] and array[j].
• While True:
• Swap array[i] with v.
• i points to a value greater than the pivot.

11

Partitioning the Array

51 1 21 32 34 8 64 2

i j

• Move i right until we find an element array[i] ≥ v
• Move j left until we find an element array[j] ≤ v.
• if i ≥ j break
• Swap array[i] and array[j].
• While True:
• Swap array[i] with v.
• i points to a value greater than the pivot.

11

Partitioning the Array

¡ ¡ ¡ ¡public ¡static ¡void ¡quicksort(Integer[] ¡a, ¡int ¡left, ¡int ¡right) ¡{ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡if ¡(right ¡> ¡left) ¡{ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡int ¡v ¡= ¡find_pivot_index(a, ¡left, ¡right); ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡int ¡i ¡= ¡0; ¡ ¡ ¡int ¡j ¡= ¡right-­‑1; ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡// ¡move ¡pivot ¡to ¡the ¡end ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡Integer ¡tmp ¡= ¡a[v]; ¡a[v] ¡= ¡a[right]; ¡a[right] ¡= ¡tmp; ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡while ¡(true) ¡{ ¡// ¡partition ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡while ¡(a[++i] ¡< ¡v) ¡{}; ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡while ¡(a[++j] ¡> ¡v) ¡{}; ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡if ¡(i ¡>= ¡j) ¡break; ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡tmp ¡= ¡a[i]; ¡a[i] ¡= ¡a[j]; ¡a[j] ¡= ¡tmp; ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡} ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡// ¡move ¡pivot ¡back ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡tmp ¡= ¡a[i]; ¡a[i] ¡= ¡a[right]; ¡a[right] ¡= ¡tmp; ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡//recursively ¡sort ¡both ¡partitions ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡quicksort(a,left, ¡i-­‑1); ¡ ¡quicksort(a,i+1, ¡right); ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡} ¡ ¡ ¡ ¡ ¡}

12

Partitioning the Array

¡ ¡ ¡ ¡public ¡static ¡void ¡quicksort(Integer[] ¡a, ¡int ¡left, ¡int ¡right) ¡{ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡if ¡(right ¡> ¡left) ¡{ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡int ¡v ¡= ¡find_pivot_index(a, ¡left, ¡right); ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡int ¡i ¡= ¡0; ¡ ¡ ¡int ¡j ¡= ¡right-­‑1; ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡// ¡move ¡pivot ¡to ¡the ¡end ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡Integer ¡tmp ¡= ¡a[v]; ¡a[v] ¡= ¡a[right]; ¡a[right] ¡= ¡tmp; ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡while ¡(true) ¡{ ¡// ¡partition ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡while ¡(a[++i] ¡< ¡v) ¡{}; ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡while ¡(a[++j] ¡> ¡v) ¡{}; ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡if ¡(i ¡>= ¡j) ¡break; ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡tmp ¡= ¡a[i]; ¡a[i] ¡= ¡a[j]; ¡a[j] ¡= ¡tmp; ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡} ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡// ¡move ¡pivot ¡back ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡tmp ¡= ¡a[i]; ¡a[i] ¡= ¡a[right]; ¡a[right] ¡= ¡tmp; ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡//recursively ¡sort ¡both ¡partitions ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡quicksort(a,left, ¡i-­‑1); ¡ ¡quicksort(a,i+1, ¡right); ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡} ¡ ¡ ¡ ¡ ¡}

O(N)

12

Quick Sort: Worst Case

• Running time depends on the how the pivot

partitions the array.

• Worst case: Pivot is always the smallest or largest
• element. One of the partitions is empty!

51 32 21 1 34 8 64 2

.
 .
 . 13

Quick Sort: Worst Case

• Running time depends on the how the pivot

partitions the array.

• Worst case: Pivot is always the smallest or largest
• element. One of the partitions is empty!

51 32 21 1 34 8 64 2 51 32 21 34 8 64 2 1

.
 .
 . 13

Quick Sort: Worst Case

• Running time depends on the how the pivot

partitions the array.

• Worst case: Pivot is always the smallest or largest
• element. One of the partitions is empty!

51 32 21 1 34 8 64 2 51 32 21 34 8 64 2 1 2 51 32 21 34 8 64

.
 .
 . 13

Quick Sort: Worst Case

51 32 21 1 34 8 64 2 51 32 21 34 8 64 2 1 2 51 32 21 34 8 64

⁞

51 64 51 64

T(1) = 1

14

Quick Sort: Worst Case

51 32 21 1 34 8 64 2 51 32 21 34 8 64 2 1 2 51 32 21 34 8 64

⁞

51 64 51 64

T(1) = 1 T(2) = T(1) + 2

Time for partitioning

14

Quick Sort: Worst Case

51 32 21 1 34 8 64 2 51 32 21 34 8 64 2 1 2 51 32 21 34 8 64

⁞

51 64 51 64

T(1) = 1 T(2) = T(1) + 2

Time for partitioning

T(N-2) = T(N-3) + (N-2)

14

Quick Sort: Worst Case

51 32 21 1 34 8 64 2 51 32 21 34 8 64 2 1 2 51 32 21 34 8 64

⁞

51 64 51 64

T(1) = 1 T(2) = T(1) + 2

Time for partitioning

T(N-1) = T(N-2) + (N-1) T(N-2) = T(N-3) + (N-2)

14

Quick Sort: Worst Case

51 32 21 1 34 8 64 2 51 32 21 34 8 64 2 1 2 51 32 21 34 8 64

⁞

51 64 51 64

T(1) = 1 T(2) = T(1) + 2 T(N) = T(N-1) + N

Time for partitioning

T(N-1) = T(N-2) + (N-1) T(N-2) = T(N-3) + (N-2)

14

Quick Sort: Worst Case

15

Quick Sort: Worst Case

15

Quick Sort: Worst Case

15

Quick Sort: Worst Case

15

Quick Sort: Worst Case

15

Quick Sort: Best Case

• Best case: Pivot is always the median element. 


Both partitions have about the same size.

51 32 21 1 34 8 64 2

16

Quick Sort: Best Case

• Best case: Pivot is always the median element. 


Both partitions have about the same size.

51 32 21 1 34 8 64 2 51 32 21 1 34 8 64 2

16

Quick Sort: Best Case

• Best case: Pivot is always the median element. 


Both partitions have about the same size.

51 32 21 1 34 8 64 2 51 32 21 1 34 8 64 2 1 8 2

16

Quick Sort: Best Case

• Best case: Pivot is always the median element. 


Both partitions have about the same size.

51 32 21 1 34 8 64 2 51 32 21 1 34 8 64 2 1 8 2 51 32 34 64

16

Quick Sort: Best Case

• Best case: Pivot is always the median element. 


Both partitions have about the same size.

51 32 21 1 34 8 64 2 51 32 21 1 34 8 64 2 1 8 2 51 32 34 64

T(N) = 2 T(N/2) +N (we ignore the pivot element, so this overestimates the running time slightly)

17

Quick Sort: Best Case

• Best case: Pivot is always the median element. 


Both partitions have about the same size.

51 32 21 1 34 8 64 2 51 32 21 1 34 8 64 2 1 8 2 51 32 34 64

T(N) = 2 T(N/2) +N T(N/2) = 2 T(N/4) +N/2 (we ignore the pivot element, so this overestimates the running time slightly)

17

Quick Sort: Best Case

• Best case: Pivot is always the median element. 


Both partitions have about the same size.

51 32 21 1 34 8 64 2 51 32 21 1 34 8 64 2 1 8 2 51 32 34 64

T(N) = 2 T(N/2) +N T(N/2) = 2 T(N/4) +N/2 T(1) = 1

⁞

(we ignore the pivot element, so this overestimates the running time slightly)

17

Quick Sort: Best Case

(note that this is the same analysis as for Merge Sort)

18

Quick Sort: Best Case

(note that this is the same analysis as for Merge Sort)

18

Quick Sort: Best Case

(note that this is the same analysis as for Merge Sort)

18

Quick Sort: Best Case

assume

(note that this is the same analysis as for Merge Sort)

18

Quick Sort: Best Case

assume

(note that this is the same analysis as for Merge Sort)

18

Quick Sort: Best Case

assume

(note that this is the same analysis as for Merge Sort)

18

Choosing the Pivot

19

Choosing the Pivot

• Ideally we want to choose the median in each

partition, but we don’t know where it is!

19

Choosing the Pivot

• Ideally we want to choose the median in each

partition, but we don’t know where it is!

• Computing the pivot should be a constant time
• peration.

19

Choosing the Pivot

• Ideally we want to choose the median in each

partition, but we don’t know where it is!

• Computing the pivot should be a constant time
• peration.
• Choosing the element at the beginning/end/middle

is a terrible idea! 
 Better: Choose a random element.

19

Choosing the Pivot

• Ideally we want to choose the median in each

partition, but we don’t know where it is!

• Computing the pivot should be a constant time
• peration.
• Choosing the element at the beginning/end/middle

is a terrible idea! Better: Choose a random element.

• Good approximation for median: “Median-of-three”

19

Choosing a Pivot: 
 Median of Three

51 32 21 1 34 8 64 2

Choose the median of array[0], array[n]m and array[n/2].

20

Choosing a Pivot: 
 Median of Three

51 32 21 1 34 8 64 2 2 1 51 32 21 34 8 64

Choose the median of array[0], array[n]m and array[n/2].

20

Choosing a Pivot: 
 Median of Three

51 32 21 1 34 8 64 2 2 1 51 32 21 34 8 64 51 32 21 34 8 64

Choose the median of array[0], array[n]m and array[n/2].

20

Choosing a Pivot: 
 Median of Three

51 32 21 1 34 8 64 2 2 1 51 32 21 34 8 64 51 32 21 34 8 64

Choose the median of array[0], array[n]m and array[n/2].

21 8 32

20

Median of Three

¡ ¡ ¡ ¡public ¡static ¡int ¡find_pivot_index(Integer[] ¡a, ¡int ¡left, ¡int ¡right) ¡{ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡int ¡center ¡= ¡( ¡left ¡+ ¡right ¡) ¡/ ¡2; ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡Integer ¡tmp; ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡if ¡(a[center] ¡< ¡a[left]) ¡{ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡tmp ¡= ¡a[center]; ¡a[center] ¡= ¡a[left]; ¡a[left] ¡= ¡tmp;} ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡if ¡(a[right] ¡< ¡a[left]) ¡{ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡tmp ¡= ¡a[right]; ¡a[right] ¡= ¡a[left]; ¡a[left] ¡= ¡tmp;} ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡if ¡(a[right] ¡< ¡a[center]) ¡{ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡tmp ¡= ¡a[right]; ¡a[right] ¡= ¡a[center]; ¡a[center] ¡= ¡tmp;} ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡return ¡center; ¡ ¡ ¡ ¡ ¡}

21

Analyzing Quick Sort

• Worst case running time: 

• Best and average case (random pivot): 

• Is QuickSort stable?


• Space requirement? 


22

Analyzing Quick Sort

• Worst case running time: 

• Best and average case (random pivot): 

• Is QuickSort stable?


• Space requirement? 


• No. Partitioning can change order of elements.


(but can make QuickSort stable).

22

Analyzing Quick Sort

• Worst case running time: 

• Best and average case (random pivot): 

• Is QuickSort stable?


• Space requirement? 


• No. Partitioning can change order of elements.


(but can make QuickSort stable). In-place O(1), but the method activation stack grows with the running time. O(N)

22

Comparison-Based Sorting Algorithms

TWorst TBest TAvg Space Stable?

Insertion Sort

✓

Shell Sort

✗

Heap Sort

✗

Merge Sort

✓

Quick Sort

✗

*depends on increment sequence

gray entries: not shown in class

23

Comparison-Based Sorting Algorithms

TWorst TBest TAvg Space Stable?

Insertion Sort

✓

Shell Sort

✗

Heap Sort

✗

Merge Sort

✓

Quick Sort

✗

*depends on increment sequence

gray entries: not shown in class

worst case lower bound on comparison based general sorting! Can we do better if we make some assumptions?

23

Bucket Sort

• Assume we know there are M possible values.
• Keep an array count of length M.
• Scan through the input array A and for each i

increment count[Ai].


2 4 6 1 1 8 2 3

A count 1 2 3 4 5 6 7 8 9

24

Bucket Sort

• Assume we know there are M possible values.
• Keep an array count of length M.
• Scan through the input array A and for each i

increment count[Ai].


2 4 6 1 1 8 2 3

A

1

count 1 2 3 4 5 6 7 8 9

25

Bucket Sort

• Assume we know there are M possible values.
• Keep an array count of length M.
• Scan through the input array A and for each i

increment count[Ai].


2 4 6 1 1 8 2 3

A

1

count 1 2 3 4 5 6 7 8 9

1

26

Bucket Sort

• Assume we know there are M possible values.
• Keep an array count of length M.
• Scan through the input array A and for each i

increment count[Ai].


2 4 6 1 1 8 2 3

A

1 1

count 1 2 3 4 5 6 7 8 9

1

27

Bucket Sort

• Assume we know there are M possible values.
• Keep an array count of length M.
• Scan through the input array A and for each i

increment count[Ai].


2 4 6 1 1 8 2 3

A

1 1 1

count 1 2 3 4 5 6 7 8 9

1

28

Bucket Sort

• Assume we know there are M possible values.
• Keep an array count of length M.
• Scan through the input array A and for each i

increment count[Ai].


2 4 6 1 1 8 2 3

A

1 2 1

count 1 2 3 4 5 6 7 8 9

1

29

Bucket Sort

• Assume we know there are M possible values.
• Keep an array count of length M.
• Scan through the input array A and for each i

increment count[Ai].


2 4 6 1 1 8 2 3

A

1 1 2 1

count 1 2 3 4 5 6 7 8 9

1

30

Bucket Sort

• Assume we know there are M possible values.
• Keep an array count of length M.
• Scan through the input array A and for each i

increment count[Ai].


2 4 6 1 1 8 2 3

A

1 1 1 2 1

count 1 2 3 4 5 6 7 8 9

1

31

Bucket Sort

• Assume we know there are M possible values.
• Keep an array count of length M.
• Scan through the input array A and for each i

increment count[Ai].


2 4 6 1 1 8 2 3

A

1 1 2 2 1

count 1 2 3 4 5 6 7 8 9

1

32

Bucket Sort

• Assume we know there are M possible values.
• Keep an array count of length M.
• Scan through the input array A and for each i

increment count[Ai].


2 4 6 1 1 8 2 3

A

1 1 2 2 1

count 1 2 3 4 5 6 7 8 9

1

O(N)

32

Bucket Sort

• Then iterate through count.For each i write

count[i] copies of i to A.
 A

1 1 2 2 1

count 1 2 3 4 5 6 7 8 9

1

33

Bucket Sort

• Then iterate through count.For each i write

count[i] copies of i to A.


1 1

A

1 1 2 2 1

count 1 2 3 4 5 6 7 8 9

1

34

Bucket Sort

• Then iterate through count.For each i write

count[i] copies of i to A.


1 1 2 2

A

1 1 2 2 1

count 1 2 3 4 5 6 7 8 9

1

35

Bucket Sort

• Then iterate through count.For each i write

count[i] copies of i to A.


3 1 1 2 2

A

1 1 2 2 1

count 1 2 3 4 5 6 7 8 9

1

36

Bucket Sort

• Then iterate through count.For each i write

count[i] copies of i to A.


3 4 1 1 2 2

A

1 1 2 2 1

count 1 2 3 4 5 6 7 8 9

1

37

Bucket Sort

• Then iterate through count.For each i write

count[i] copies of i to A.


3 4 1 1 2 2

A

1 1 2 2 1

count 1 2 3 4 5 6 7 8 9

1

38

Bucket Sort

• Then iterate through count.For each i write

count[i] copies of i to A.


3 4 6 1 1 2 2

A

1 1 2 2 1

count 1 2 3 4 5 6 7 8 9

1

39

Bucket Sort

• Then iterate through count.For each i write

count[i] copies of i to A.


3 4 6 1 1 2 2

A

1 1 2 2 1

count 1 2 3 4 5 6 7 8 9

1

40

Bucket Sort

• Then iterate through count.For each i write

count[i] copies of i to A.


3 4 6 8 1 1 2 2

A

1 1 2 2 1

count 1 2 3 4 5 6 7 8 9

1

41

Bucket Sort

• Then iterate through count.For each i write

count[i] copies of i to A.


3 4 6 8 1 1 2 2

A

1 1 2 2 1

count 1 2 3 4 5 6 7 8 9

1

42

Bucket Sort

• Then iterate through count.For each i write

count[i] copies of i to A.


3 4 6 8 1 1 2 2

A

1 1 2 2 1

count 1 2 3 4 5 6 7 8 9

1

O(M)

42

Bucket Sort

• Then iterate through count.For each i write

count[i] copies of i to A.


3 4 6 8 1 1 2 2

A

1 1 2 2 1

count 1 2 3 4 5 6 7 8 9

1

O(M)

Total time for Bucket Sort:O(N +M)

42

Radix Sort

• Generalization of Bucket sort for Large M.
• Assume M contains all base b numbers up to bp-1


(e.g. all base-10 integers up to 103)

• Do p passes over the data, using Bucket Sort for

each digit.

• Bucket sort is stable!

064 008 216 512 027 729 000 001 343 125

43

064 008 216 512 027 729 000 001 343 125

1 2 3 4 5 6 7 8 9

Radix Sort

064

• Bucket sort according

to least significant digit.

44

064 008 216 512 027 729 000 001 343 125

1 2 3 4 5 6 7 8 9

Radix Sort

064 008

• Bucket sort according

to least significant digit.

45

064 008 216 512 027 729 000 001 343 125

1 2 3 4 5 6 7 8 9

Radix Sort

064 008 216

• Bucket sort according

to least significant digit.

46

064 008 216 512 027 729 000 001 343 125

1 2 3 4 5 6 7 8 9

Radix Sort

064 008 216 512

• Bucket sort according

to least significant digit.

47

064 008 216 512 027 729 000 001 343 125

1 2 3 4 5 6 7 8 9

Radix Sort

064 008 216 512 027

• Bucket sort according

to least significant digit.

48

064 008 216 512 027 729 000 001 343 125

1 2 3 4 5 6 7 8 9

Radix Sort

064 008 216 512 027 729

• Bucket sort according

to least significant digit.

49

064 008 216 512 027 729 000 001 343 125

1 2 3 4 5 6 7 8 9

Radix Sort

064 008 216 512 027 729 000

• Bucket sort according

to least significant digit.

50

064 008 216 512 027 729 000 001 343 125

1 2 3 4 5 6 7 8 9

Radix Sort

064 008 216 512 027 729 000 001

• Bucket sort according

to least significant digit.

51

064 008 216 512 027 729 000 001 343 125

1 2 3 4 5 6 7 8 9

Radix Sort

064 008 216 512 027 729 000 001 003

• Bucket sort according

to least significant digit.

52

064 008 216 512 027 729 000 001 343 125

1 2 3 4 5 6 7 8 9

Radix Sort

064 008 216 512 027 729 000 001 003 125

• Bucket sort according

to least significant digit.

53

1 2 3 4 5 6 7 8 9

Radix Sort

064 008 216 512 027 729 000 001 003 125 000 001 512 343 064 125 216 027 008 729

• read off new sequence

54

1 2 3 4 5 6 7 8 9

Radix Sort

000 001 512 343 064 125 216 027 008 729 000

• Bucket sort according

to second-least significant digit.

55

1 2 3 4 5 6 7 8 9

Radix Sort

000 001 512 343 064 125 216 027 008 729 000 001

• Bucket sort according

to second-least significant digit.

56

1 2 3 4 5 6 7 8 9

Radix Sort

000 001 512 343 064 125 216 027 008 729 000 001 512

• Bucket sort according

to second-least significant digit.

57

1 2 3 4 5 6 7 8 9

Radix Sort

000 001 512 343 064 125 216 027 008 729 000 001 512 343

• Bucket sort according

to second-least significant digit.

58

1 2 3 4 5 6 7 8 9

Radix Sort

000 001 512 343 064 125 216 027 008 729 000 001 512 343 064

• Bucket sort according

to second-least significant digit.

59

1 2 3 4 5 6 7 8 9

Radix Sort

000 001 512 343 064 125 216 027 008 729 000 001 512 343 064 125

• Bucket sort according

to second-least significant digit.

60

1 2 3 4 5 6 7 8 9

Radix Sort

000 001 512 343 064 125 216 027 008 729 000 001 512 343 064 125 216

• Bucket sort according

to second-least significant digit.

61

1 2 3 4 5 6 7 8 9

Radix Sort

000 001 512 343 064 125 216 027 008 729 000 001 512 343 064 125 216 027

• Bucket sort according

to second-least significant digit.

62

1 2 3 4 5 6 7 8 9

Radix Sort

000 001 512 343 064 125 216 027 008 729 000 001 512 343 064 125 216 027 008

• Bucket sort according

to second-least significant digit.

63

1 2 3 4 5 6 7 8 9

Radix Sort

000 001 512 343 064 125 216 027 008 729 000 001 512 343 064 125 216 027 008 729

• Bucket sort according

to second-least significant digit.

64

1 2 3 4 5 6 7 8 9

Radix Sort

000 001 008 512 216 125 027 729 343 064 000 001 512 343 064 125 216 027 008 729

• read off new sequence

65

1 2 3 4 5 6 7 8 9

Radix Sort

000 001 008 512 216 125 027 729 343 064

• Bucket sort according

to third-least significant digit. 000 001 008 512 216 125 027 729 343 064

66

1 2 3 4 5 6 7 8 9

Radix Sort

000 001 008 027 064 125 216 343 512 729 000 001 008 512 216 125 027 729 343 064

• read off new sequence
• Sorted!

67

1 2 3 4 5 6 7 8 9

Radix Sort

000 001 008 027 064 125 216 343 512 729 000 001 008 512 216 125 027 729 343 064

• read off new sequence
• Sorted!

Each Bucket Sort: O(N+b) There are p Bucket Sorts, 
 so total time for Radix sort: O(p (N+b))

67

a b c d e

Sorting Strings with Radix Sort

… 97 98 99 100 101 … 256 bad fad bid die pie pre dna bob nib sic

• f

by in

68