Radix Sort (Chapter 10) Comparison sorting has runtime  (n log n). Can we do better? To do better, we must use more information from the key. Look at the bits. Radix sort: treat the keys as radix-R (i.e. base-R) numbers.

Sorting Zip Codes How would you sort a set of integers in the range 0..9 in O(n) time? use 10 buckets (linked lists) to accumulate the items. How would you sort a set of zip codes in O(n) time? use 10 buckets to accumulate items sort once for digit 5 (least significant), then 4, then 3, then 2, then 1. (LSD sort) note that each stage must be stable (you can sort from left to right (MSD) if you are clever.) Sorting machines for punched cards…

Radix Sort Utilities We need to be able to get a chunk out of a key. inline int digit(int a, int digit, int radix) { return (a / pow(radix,digit)) % radix; } It could be a fixed number of bits–often that’s fastest. const int bitsword = 32; bitschunk = 4; const int chunksword = bitsword/bitschunk; const int radix = 1 << bitschunk; inline int digit(long a, int b) { return (a >> bitschunk*(chunksword-b-1)) & (radix-1); }

Binary Quicksort How about using bits as pivots for quicksort? move all numbers starting with bit 0 before those starting with bit 1 (like a Quicksort partition on 10000…) recursively sort each half on bit 2, each quarter on bit 3, …

Binary Quicksort: Runtime? b passes, where b is the number of bits per word O(n) time per pass O(b n) = O(n) worst case but in practice it’s worse than quicksort – high constant. actually, you may not even have to look at all the input bits! but what happens if we sort many small number?

MSD Radix Sort Like binary quicksort – but with larger chunk size But how can we move items into the correct place in one pass? Need to count the number of items starting with a, b, c, etc. Then we can move items into place in one pass. (Hmmm, let’s see…the place for the first c word will be after all the a and b words…)

MSD Radix Sort – code #define bin(A) 1+count[A] template void radixMSD(Item a[], int l, int r, int d) { int i, j, count[R+1]; static Item aux[maxN] if (d > bytesword) return; if (r-1 <= M) {insertion(a, l, r); return; } for (j=0; j<R; j++) count[j] = 0; for (i=l; i<=r; i++) count[digit(a[i],d)+1]++; for (j=1; j<R; j++) count[j] += count[j-1]; for (int i=l; i<=r; i++) aux[count[digit(a[i],d)]++] = a[i]; for (i=l; i<=r; i++) a[i] = aux[i-l]; radixMSD(a, l, bin(0)-1, d+1); for (j=0; j<R-1; j++) radixMSD(a, bin(j), bin(j+1)-1, d+1); }

LSD Binary If we work from right to left – what changes? Just do a stable pass for each bit!

LSD Radix Sort Like LSD Binary sort – but on bigger chunks of the key. We still need to count the number of each type to figure out where to move items in one pass Runtime is still O(n).

LSD Radix Sort -- code template void radixLSD(Item a[], int l, int r) { static Item aux[maxN]; for (int d = bytesword-1; d>=0; d--) { int i, j, count[R+1]; for (j=0; j<R; j++) count[j] = 0; for (i=l; i<=r; i++) count[digit(a[i],d)+1]++; for (j=1; j<R; j++) cout[j] += count[j-1]; for (i=l; i<=r; i++) aux[count[digit(a[i],d)]++] = a[i]; for (i=l; i<=r; i++) a[i] = aux[i-l]; }

Empirical Results Radix sort can be fastest, if used with care E.g. sorting random files of N 32-bit ints, with cutoff to insertion sort for N<16: 4-bit 8-bit N Q M L M L L* Q = standard quicksort M = MSD radix sort L = LSD radix sort L* = LSD radix sort on MSD half of the bits