COS 212

Sorting:
Radix Sort & Counting
Sort
Bucket Sort
 How would you sort a pile of books?
 You could sort the books by the name of the author
 Create 26 separate piles, one for each letter of the alphabet
 Books by authors whose names start with ‘A’ go in 1st pile,
books by authors whose names start with ‘B’ go in 2nd pile, and
so on…

 Now you have your books organised by first letter

 But there are still a lot of books by different authors in each
pile…
 Sort each one of the 26 piles in the same way
 Create 26 piles within one of the original piles
 Books by authors whose names have a second letter of ‘A’ go in 1 st pile,
books by authors whose names have a second letter of ‘B’ go in 2 nd pile,
and so on…

 Do this until only one author’s books are in each pile

 This is a legitimate sorting algorithm used in the real
world
Radix Sort
 Can we do the same thing with numbers?
 We can sort by each digit, creating 10 buckets (for digits 0 to 9)
 Let’s see how this works if we start with the first digit & move
right
10
12 23
data = [12 23 2 17
17 100]
0
10
0
17
12
0 1 2 3 4 5 6 7 8 9

0 1 2 3 4 5 6 7 8 9

 But we immediately have a problem

 The values starting with 1 are sorted into the incorrect order
 Clearly sorting left to right doesn’t work
Radix Sort
 How could we solve this problem?
 Sort right to left, starting with the rightmost digit
 Pad numbers with leading zeros to make them the same length
 To store the multiple values that map to a digit
 We’ll use one queue per digit
 Our previous example also wastes a lot of memory
 A separate destination array for each digit
 Process repeated as many times as maximum digits in a
number
 Leads to a proliferation of arrays
 We’ll move numbers back and forth between the array we’re
sorting and a single array of queues
radixSort(data[])
n = number of digits in largest number
add leading zeros to numbers until all have n digits
for d = n down to 1
distribute numbers in data[] among queues 0 to 9 according to
digit d
for i = 0 up to 9
dequeue each number in queue i and add to next position in
Radix Sort
 Let’s apply radix sort to the array [25 5 20 315 11 77]
data = [025
02 0000502020
31315
01 011
07
5 5 077]
0 5 1 7

0 1 2 3 4 5 6 7 8 9
Radix Sort
 Let’s apply radix sort to the array [25 5 20 315 11 77]
data = [025
02 0100502020
00315
31 011
07
0 1 077]
5 5 5 7

0 1 2 3 4 5 6 7 8 9
Radix Sort
 Let’s apply radix sort to the array [25 5 20 315 11 77]
data = [025
00 0100531020
02315
02 011
07
5 1 077]
5 0 5 7
= [5 11 20 25 77 315]

0 1 2 3 4 5 6 7 8 9

Do you think it’s

possible to
implement radix sort
recursively?
Radix Sort

 Radix sort can be applied to binary representations

 At each pass, sort according to b bits, starting from the right
 How many queues?
 Determined by the number of different bit strings of size b
 For b = 2 there are bit strings, and therefore 4 queues: 00, 01, 10,
11
 A larger value for b results in
 More queues (wastes space) but fewer passes (saves time)
 A smaller value for b results in
 Fewer queues (saves space) but more passes (wastes time)
Radix Sort: Efficiency
private final int radix = 10; // number of digits and
buckets
private final int digits = 10; // max number of digits in a
number

public void radixsort(int[] data) {

int d, j, k, factor;
O(1) Queue<Integer>[] queues = new Queue[radix];//1 queue per
bucket
for (d = 0; d < radix; d++)
O(d) queues[d] = new Queue<Integer>();
// run through every digit, starting from the rightmost
O(n) for (d = 1, factor = 1; d <= digits; factor *= radix, d+
+) {
for (j = 0; j < data.length; j++) // enqueue
O(n)
data[j]
queues[(data[j] / factor) %
radix].enqueue(data[j]);
for (j = k = 0; j < radix; j++) // rebuild
data What about the
Total complexity? O(dn) complexity of using
while (!queues[j].isEmpty())
queues?
data[k++] = queues[j].dequeue();
Counting Sort
 Array indices are always sorted (0 up to size-1)

6 7 2 5 1 0 3 4
0 1 2 3 4 5 6 7
 What if we treat each element as an index?
 Create array tmp where last index is the largest data
value
What if there
are duplicate
0 1 2 3 4 5 6 7 values?

 Populate tmp array: tmp[array[i]] = array[i]

What if there
0 1 2 3 4 5 6 7 are gaps
between
0 1 2 3 4 5 6 7 numbers?
Counting Sort
count occurrences of each number in data[];
store occurrences in count[] indexed with numbers in
data[];
for i = 1 up to count.length-1
count[i] = the number of elements <= i;
// transfer numbers from data[] to tmp[] Last index in
for i = n-1 down to 0 count[] is equal to
tmp[count[data[i]] - 1] = data[i];the largest number
decrement count[data[i]]; in data[]
transfer numbers from tmp[] to data[];
data[
count[]
]
0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 8 9
7 2 9 3 7 3 4 1 0 1
0 0
1 1 0 0 0 12
0 1
2 0 0 0
1

0 1 2 3 4 5 6 7 8 9
count[i] = count[i – 1] +
0 1 2
1 4
2 1
5 5
0 0
5 2
7 0
7 1
8
count[i]
 Counting Sort for i = n-1 down to 0
tmp[count[data[i]]-1] =
0 1 2 3 4 5 6 7 data[i];
data[ decrement count[data[i]];
7 2 9 3 7 3 4 1
]

0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 8 9
tmp[ count[
0 1 2 4 5 5 5 7 7 8
] ]

1 0 0 2 4 5 5 5 7 7 8

1 4 0 0 2 4 4 5 5 7 7 8

1 3 4 0 0 2 3 4 5 5 7 7 8

1 3 4 7 0 0 2 3 4 5 5 6 7 8

1 3 3 4 7 0 0 2 2 4 5 5 6 7 8

1 3 3 4 7 9 0 0 2 2 4 5 5 6 7 7

1 2 3 3 4 7 9 0 0 1 2 4 5 5 6 7 7

1 2 3 3 4 7 7 9 0 0 1 2 4 5 5 5 7 7
Counting Sort: Complexity
count occurrences of each number in data[];
store occurrences in count[] indexed with numbers in
data[];
for i = 1 up to count.length-1
count[i] = the number of elements <= i; O(n)
// transfer numbers from data[] to tmp[]
for i = n-1 down to 0 O(n)
tmp[count[data[i]] - 1] = data[i];
decrement count[data[i]]; How many
O(n) times will the
transfer numbers from tmp[] to data[];
loop execute?
O(n +
Total complexity?
max) O(max)

 Imagine data looks like this: 3 5 100000000

 Counting sort is very efficient, but only if

This number
max is not much larger than n
determines max
 Can counting sort work on non-integers e.g. strings?
 Counting Radix Sort
public static void countingRadixSort(String[] data, int stringLen) {
final int BUCKETS = 128; // 7bit ASCII
int N = data.length; // number of strings
String[] tmp = new String[N];
String[] in = data; String[] out = tmp;
for(int pos = stringLen - 1; pos >= 0; pos--) // repeat for each
character
{ // in string starting
with last
int[] count = new int[BUCKETS]; // bucket for each ASCII character
for(int i = 0; i < N; i++)
count[in[i].charAt(pos)]++; // count ASCII characters per bucket
for(int b = 1; b < BUCKETS; b++)
count[b] += count[b - 1]; // count ASCII characters <= b
for(int i = 0; i < N; i++) {
out[count[in[i].charAt(pos)] - 1] = in[i]; // place strings in
correct
count[in[i].charAt(pos)]--; // position in tmp
array
}
// swap in and out roles
String[] backup = in; in = out; out = backup;
}
// if odd number of passes, in is tmp, out is data; so copy back
if(stringLen % 2 == 1) for(int i = 0; i < N; i++) out[i] = in[i];
}  Can counting sort work on non-integers e.g. strings?
 Only efficiently in combination with radix sort.
Which Algorithm Should You Use?
20,000 Integers
Ascending Random Descending
Insertion sort .06 1 m 2.73 1 m 40.57
Selection sort 3 m 13.5 3 m 21.31 3 m 23.56
Bubble sort 2 m 58.51 4 m 47.81 5 m 3.90
Comb sort .15 1.05 .67
Shell sort .22 .49 .33
Heap sort .72 .88 .72
Merge sort .50 .66 .49
Quick sort .16 .44 .22
Radix sort 2.31 1.59 2.20
Counting sort .05 .08 .05
Which Algorithm Should You Use?
80,000 Integers
Ascending Random Descending
Insertion sort .11 29 m 2.73 29 m 36.13
Selection sort 56 m 8.09 67 m 21.31 56 m 49.94
Bubble sort 52 m 6.90 87 m 9.62 83 m 6.68
Comb sort .67 6.52 3.10
Shell sort 1.32 2.75 1.59
Heap sort 3.63 4.56 3.35
Merge sort 2.19 3.35 2.20
Quick sort .93 2.04 .99
Radix sort 10.98 10.82 10.00
Counting sort .22 .57 .20

It will always depend on the application

Just be sure to avoid the simple sorting algorithms!