Radix sort is a non-comparative sorting algorithm that sorts data based on the individual digit positions of integer keys. It works by performing multiple passes over the data, where each pass groups keys by a specific digit (from least to most significant). A stable sorting method is used to group the keys in each pass. This results in a running time of O(dn) for d digit positions and n keys.

1. RADIX SORT

2. RADIX SORT
• Radix sort is a non-comparative integer sorting algorithm that sorts
data with integer keys by grouping keys by the individual digits which
share the same significant position and value.
• A positional notation is required, but because integers can represent
strings of characters (e.g., names or dates), radix sort is not limited to
integers

3. PSEUDOCODE
• RADIX_SORT (A, d)
1. for i = 1 to d
2. Stable_Sort (A) on digit i

4. EXAMPLE
• Let’s sort the following array using radix sort:
A[10] =
64 8 216 512 27 729 0 1 343 125

5. PASS 1
A[10] =
8 216 512 27 729 0 1 343 12564

6. PASS 1
Sorted Array after pass 1 (LSD)
A[10] =
1 512 343 64 125 216 27 8 7290

7. PASS 2
A[10] =
01 512 343 64 125 216 27 08 72900

8. PASS 2
Sorted Array after pass 2 :
A[10] =
01 08 512 216 125 27 729 343 6400

9. PASS 3
A[10] =
001 008 512 216 125 027 729 343 064000

10. PASS 3
Sorted Array after pass 3 :
A[10] =
001 008 027 064 125 216 343 512 729000

11. ANALYSIS
• Assume that we use counting sort as the intermediate sort.
• Ө(n+k) per pass (digits in the range 0,….,k)
• d passes
• Total = Ө(d(n+k))
• If k=O(n), Time = Ө(dn)

12. Can we prove it will work?
• Basis: If d = 1, there’s only one digit, so sorting on that digit sorts the array.
• Inductive Step:
• Assume lower-order digits {j: j<i} are sorted
• Show that sorting next digit i leaves array correctly sorted
• If two digits at position i are different, ordering numbers by that digit is
correct.
• If they are the same, numbers are already sorted on the lower-order digits.
Since we use a stable sort, the numbers stay in the right order

13. How to break each key into digits? (Lemma 8.4)
• n keys
• b bits/key
• Break into r-bit digits (r ≤ b). Have d =
𝒃
𝒓
• Use counting sort, k = 2 𝑟
-1

14. EXAMPLE
• 32- bit keys, 8- bit digits.
• b = 32, r = 8, d = 32/8 = 4
• k = 28 – 1 = 255
• Time = Ө(b/r(n + 2 𝑟
))

15. • If b < lgn
 (n + 2 𝑟) = Ө(n). Thus, choosing r = b yields an optimal running time
of (b/b(n + 2 𝑏)) = Ө(n)
• If b ≥ lgn
Choosing r = lgn yields a running time of Ө(bn/lgn)
If lgn > r > lgn, Time = Ω(bn/lgn)