Radix Sort Algorithm in DSA Go - Deep Dive

Overview - Radix Sort Algorithm

What is it?

Radix Sort is a way to sort numbers by looking at their digits one by one. It starts sorting from the least important digit (like the ones place) and moves to the most important digit (like the thousands place). It uses a stable sorting method to keep the order of numbers with the same digit. This method works well when sorting many numbers with similar digit lengths.

Why it matters

Without Radix Sort, sorting large lists of numbers digit by digit would be slow or complicated. Radix Sort solves this by breaking the problem into smaller, easier steps, making sorting faster for certain cases. This helps in applications like sorting phone numbers, IDs, or large datasets where speed matters. Without it, some sorting tasks would take much longer and use more resources.

Where it fits

Before learning Radix Sort, you should understand basic sorting methods like Bubble Sort and Counting Sort. After Radix Sort, you can explore more advanced sorting algorithms like Quick Sort and Merge Sort, and learn about algorithm efficiency and stability.

Mental Model

Core Idea

Radix Sort sorts numbers by processing each digit from least to most significant, grouping numbers by digits at each step to achieve a fully sorted list.

Think of it like...

Imagine sorting a stack of mail by zip code digits: first by the last digit, then the second last, and so on, until the whole stack is sorted by the full zip code.

Step 1: Sort by least significant digit (LSD)
┌───────────────┐
│ 170, 45, 75  │
│ 90, 802, 24  │
│ 2, 66        │
└───────────────┘

Step 2: Sort by next digit
┌───────────────┐
│ 802, 2, 24   │
│ 45, 66, 170  │
│ 75, 90       │
└───────────────┘

Step 3: Sort by most significant digit
┌───────────────┐
│ 2, 24, 45    │
│ 66, 75, 90   │
│ 170, 802     │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Digits in Numbers

Concept: Numbers have digits in places like ones, tens, hundreds, each with different importance.

Every number is made of digits. For example, 345 has 3 in hundreds place, 4 in tens, and 5 in ones. Radix Sort looks at these digits one place at a time to sort numbers.

Result

You can identify and separate digits of numbers by their place value.

Understanding digits and their places is key to breaking down sorting into smaller, manageable steps.

2

Foundation

Stable Sorting by Single Digit

Concept: Sorting numbers by one digit at a time requires a stable sorting method to keep order of equal digits.

Stable sorting means if two numbers have the same digit, their order stays the same after sorting. Counting Sort is often used here because it sorts quickly and keeps order.

Result

Numbers sorted by one digit maintain their relative order if digits are equal.

Stable sorting ensures that sorting by later digits doesn't mess up the order from earlier digits.

3

Intermediate

Sorting from Least Significant Digit

🤔Before reading on: do you think sorting should start from the biggest digit or the smallest digit? Commit to your answer.

Concept: Radix Sort starts sorting from the least important digit to the most important digit.

We begin sorting numbers by the digit in the ones place, then move to tens, then hundreds, and so on. This order ensures that after all passes, the list is fully sorted.

Result

After sorting by the least significant digit, numbers are grouped by their last digit.

Starting from the smallest digit allows the sorting to build up correctly without losing previous order.

4

Intermediate

Using Counting Sort as Subroutine

🤔Before reading on: do you think Radix Sort can use any sorting method for digits or only stable ones? Commit to your answer.

Concept: Radix Sort uses Counting Sort to sort numbers by each digit because Counting Sort is stable and efficient for small ranges.

Counting Sort counts how many times each digit appears and places numbers in order based on these counts. This keeps the order of numbers with the same digit intact.

Result

Numbers are sorted by the current digit without changing the order of equal digits.

Using Counting Sort ensures each digit sorting step is fast and stable, which is essential for Radix Sort correctness.

5

Intermediate

Handling Different Digit Lengths

Concept: Radix Sort can handle numbers with different digit lengths by treating missing digits as zero.

For example, number 2 can be treated as 002 when sorting with three-digit numbers. This way, all numbers have the same digit count and can be sorted uniformly.

Result

Numbers with fewer digits are correctly placed relative to longer numbers.

Normalizing digit lengths prevents errors and ensures consistent sorting across all numbers.

6

Advanced

Implementing Radix Sort in Go

🤔Before reading on: do you think Radix Sort modifies the original list in place or creates new lists each pass? Commit to your answer.

Concept: Radix Sort implementation involves looping over digit places and applying Counting Sort repeatedly.

In Go, you create a function to extract digits, then loop from least to most significant digit. For each digit, apply Counting Sort to reorder the list. This process repeats until all digits are processed.

Result

The original list becomes fully sorted after all digit passes.

Understanding the loop and stable sorting at each digit is crucial for correct and efficient Radix Sort implementation.

7

Expert

Performance and Limitations of Radix Sort

🤔Before reading on: do you think Radix Sort is always faster than comparison-based sorts like Quick Sort? Commit to your answer.

Concept: Radix Sort runs in linear time relative to number of digits and items but depends on digit size and data type.

Radix Sort is very fast for fixed-length integers or strings but can be slower or use more memory for large digit ranges or floating-point numbers. It also requires extra space for Counting Sort steps.

Result

Radix Sort is efficient for certain data but not always the best choice for all sorting tasks.

Knowing when Radix Sort shines or struggles helps choose the right sorting method for real-world problems.

Under the Hood

Radix Sort works by repeatedly grouping numbers based on individual digit values using a stable sort. Internally, it extracts digits using division and modulo operations, then applies Counting Sort to reorder numbers by those digits. This process preserves the order of numbers with equal digits, building up a fully sorted list after processing all digit places.

Why designed this way?

Radix Sort was designed to avoid the O(n log n) lower bound of comparison sorts by exploiting the fixed structure of digits. Using stable Counting Sort for each digit pass ensures correctness without complex comparisons. This design trades extra space and multiple passes for faster sorting on suitable data types.

Input List
  ↓ Extract digit (ones place)
┌───────────────┐
│ Counting Sort │
└───────────────┘
  ↓ Sorted by ones digit
  ↓ Extract digit (tens place)
┌───────────────┐
│ Counting Sort │
└───────────────┘
  ↓ Sorted by tens digit
  ↓ Extract digit (hundreds place)
┌───────────────┐
│ Counting Sort │
└───────────────┘
  ↓ Fully Sorted List

Myth Busters - 4 Common Misconceptions

Quick: Do you think Radix Sort compares numbers directly to sort them? Commit yes or no.

Common Belief: Radix Sort compares numbers directly like Quick Sort or Merge Sort.

Reality: Radix Sort does not compare whole numbers; it sorts by individual digits using Counting Sort.

Why it matters: Believing it compares numbers leads to misunderstanding its speed and when it is useful.

Quick: Do you think Radix Sort works well for floating-point numbers without changes? Commit yes or no.

Common Belief: Radix Sort can sort any numbers, including floats, without modification.

Reality: Radix Sort needs special handling for floats because their binary representation is complex and not digit-based like integers.

Why it matters: Using Radix Sort directly on floats can produce incorrect results or require complex adaptations.

Quick: Do you think Radix Sort always uses less memory than other sorts? Commit yes or no.

Common Belief: Radix Sort uses less memory because it sorts digits instead of whole numbers.

Reality: Radix Sort uses extra memory for Counting Sort arrays and temporary lists during each digit pass.

Why it matters: Underestimating memory use can cause problems in memory-limited environments.

Quick: Do you think Radix Sort is always faster than comparison-based sorts? Commit yes or no.

Common Belief: Radix Sort is always faster than Quick Sort or Merge Sort.

Reality: Radix Sort is faster only when the number of digits is small compared to the number of items; otherwise, comparison sorts can be faster.

Why it matters: Choosing Radix Sort blindly can lead to slower performance in some cases.

Expert Zone

1

Radix Sort's efficiency depends heavily on the digit base chosen; using base 256 or 65536 can reduce passes but increase Counting Sort complexity.

2

The stability of the underlying sort is critical; even a small instability breaks the entire sorting correctness.

3

Radix Sort can be adapted for strings by treating characters as digits, but requires careful handling of variable string lengths.

When NOT to use

Avoid Radix Sort when sorting floating-point numbers without special handling, very large digit ranges, or when memory is very limited. Use comparison-based sorts like Quick Sort or Merge Sort in these cases.

Production Patterns

In production, Radix Sort is used for sorting fixed-length integers like IDs, IP addresses, or sorting large datasets where linear time sorting is beneficial. It is often combined with hybrid approaches that switch to comparison sorts for small sublists.

Connections

Counting Sort

Radix Sort builds on Counting Sort as a stable subroutine for sorting digits.

Understanding Counting Sort's stability and efficiency is essential to grasp why Radix Sort works correctly and fast.

Bucket Sort

Radix Sort is related to Bucket Sort as both distribute elements into groups based on parts of their value.

Knowing Bucket Sort helps understand how Radix Sort groups numbers by digits to simplify sorting.

Human Sorting of Postal Codes

Radix Sort mimics how humans sort mail by zip code digits from right to left.

Recognizing this real-world process clarifies why sorting digits from least to most significant works.

Common Pitfalls

#1 Using an unstable sort for digit sorting.

Wrong approach:

func unstableSortByDigit(arr []int, digit int) []int {
// Using a non-stable sort like quicksort here
sort.Slice(arr, func(i, j int) bool {
return getDigit(arr[i], digit) < getDigit(arr[j], digit)
})
return arr
}

Correct approach:

func stableCountingSortByDigit(arr []int, digit int) []int {
// Use Counting Sort to keep stability
// Implementation of counting sort here
return sortedArr
}

Root cause:

Not realizing that stability is required to preserve order from previous digit sorts.

#2 Ignoring numbers with fewer digits during sorting.

Wrong approach:

func getDigit(num int, digit int) int {
return (num / int(math.Pow10(digit))) % 10
}
// No padding or handling for shorter numbers

Correct approach:

func getDigit(num int, digit int) int {
// Treat missing digits as 0
return (num / int(math.Pow10(digit))) % 10
}

Root cause:

Assuming all numbers have the same digit length without padding or zero handling.

#3 Sorting digits from most significant to least significant.

Wrong approach:

for digit := maxDigit; digit >= 0; digit-- {
arr = stableCountingSortByDigit(arr, digit)
}

Correct approach:

for digit := 0; digit <= maxDigit; digit++ {
arr = stableCountingSortByDigit(arr, digit)
}

Root cause:

Misunderstanding the order of digit processing required for Radix Sort correctness.

Key Takeaways

Radix Sort sorts numbers by processing digits from least to most significant using a stable sort at each step.

Stability in sorting digits is essential to maintain the correct order and achieve a fully sorted list.

Radix Sort is efficient for fixed-length integers and certain data types but has limits with floats and large digit ranges.

Understanding digit extraction and stable sorting is key to implementing Radix Sort correctly.

Choosing the right sorting algorithm depends on data type, size, and performance needs; Radix Sort is one powerful tool among many.

Practice

1. What is the main idea behind the Radix Sort Algorithm?

easy

A. Sort numbers by dividing the list into halves recursively

B. Sort numbers by processing individual digits from least to most significant

C. Sort numbers by comparing each pair directly

D. Sort numbers by swapping adjacent elements repeatedly

Solution

1. Step 1: Understand Radix Sort approach

   Radix Sort sorts numbers by grouping digits and sorting them digit by digit, starting from the least significant digit.

2. Step 2: Compare with other sorting methods

   Unlike comparison-based sorts (like bubble or merge sort), Radix Sort processes digits individually without direct element comparisons.

3. Final Answer:

   Sort numbers by processing individual digits from least to most significant -> Option B

4. Quick Check:

   Radix Sort = Digit-wise sorting [OK]

Hint: Radix Sort sorts digits from right to left [OK]

Common Mistakes:

• Thinking Radix Sort compares elements directly
• Confusing Radix Sort with divide and conquer methods
• Assuming it swaps adjacent elements like bubble sort

2. Which of the following is the correct way to initialize a slice of buckets for Radix Sort in Go?

easy

A. buckets := [][]int{}

B. buckets := make([]int, 10)

C. buckets := make([][]int, 10)

D. buckets := [10]int{}

Solution

1. Step 1: Identify bucket type needed

   Radix Sort uses buckets to hold multiple integers per digit, so each bucket must be a slice of ints.

2. Step 2: Choose correct slice initialization

   Using make([][]int, 10) creates a slice of 10 slices, perfect for buckets 0-9.

3. Final Answer:

   buckets := make([][]int, 10) -> Option C

4. Quick Check:

   Slice of slices for buckets = buckets := make([][]int, 10) [OK]

Hint: Buckets hold slices, so use [][]int with make [OK]

Common Mistakes:

• Using single int slice instead of slice of slices
• Using array instead of slice for dynamic buckets
• Initializing empty slice without length

3. What will be the output of the following Go code snippet using Radix Sort on the array [170, 45, 75, 90, 802, 24, 2, 66]?

package main
import "fmt"
func main() {
  arr := []int{170, 45, 75, 90, 802, 24, 2, 66}
  radixSort(arr)
  fmt.Println(arr)
}

func radixSort(arr []int) {
  max := getMax(arr)
  exp := 1
  for max/exp > 0 {
    countSort(arr, exp)
    exp *= 10
  }
}

func getMax(arr []int) int {
  max := arr[0]
  for _, v := range arr {
    if v > max {
      max = v
    }
  }
  return max
}

func countSort(arr []int, exp int) {
  n := len(arr)
  output := make([]int, n)
  count := make([]int, 10)

  for i := 0; i < n; i++ {
    index := (arr[i] / exp) % 10
    count[index]++
  }

  for i := 1; i < 10; i++ {
    count[i] += count[i-1]
  }

  for i := n - 1; i >= 0; i-- {
    index := (arr[i] / exp) % 10
    output[count[index]-1] = arr[i]
    count[index]--
  }

  for i := 0; i < n; i++ {
    arr[i] = output[i]
  }
}

medium

A. [2 24 45 66 75 90 802 170]

B. [802 170 90 75 66 45 24 2]

C. [170 45 75 90 802 24 2 66]

D. [2 24 45 66 75 90 170 802]

Solution

1. Step 1: Understand Radix Sort process on given array

   Radix Sort sorts by digits from least significant to most significant. After sorting by units, tens, and hundreds place, the array becomes sorted.

2. Step 2: Trace final sorted array

   The final sorted array is ascending: [2, 24, 45, 66, 75, 90, 170, 802].

3. Final Answer:

   [2 24 45 66 75 90 170 802] -> Option D

4. Quick Check:

   Radix Sort output = Sorted ascending array [OK]

Hint: Radix Sort outputs sorted array ascending [OK]

Common Mistakes:

• Confusing order of digits processed
• Misreading output as original array
• Mixing up output with descending order

4. Identify the bug in this Radix Sort countSort function snippet in Go:

func countSort(arr []int, exp int) {
  n := len(arr)
  output := make([]int, n)
  count := make([]int, 10)

  for i := 0; i < n; i++ {
    index := (arr[i] / exp) % 10
    count[index]++
  }

  for i := 1; i < 10; i++ {
    count[i] += count[i-1]
  }

  for i := 0; i < n; i++ {
    index := (arr[i] / exp) % 10
    output[count[index]-1] = arr[i]
    count[index]--
  }

  for i := 0; i < n; i++ {
    arr[i] = output[i]
  }
}

medium

A. The last for loop should iterate backwards from n-1 to 0

B. The count array size should be 100 instead of 10

C. The output slice should be initialized with zeros explicitly

D. The index calculation should use modulo 100 instead of 10

Solution

1. Step 1: Check order of placing elements in output

   To maintain stable sorting, elements must be placed from right to left (backwards) in output.

2. Step 2: Identify incorrect loop direction

   The code uses a forward loop (0 to n-1) which breaks stability; it should loop from n-1 down to 0.

3. Final Answer:

   The last for loop should iterate backwards from n-1 to 0 -> Option A

4. Quick Check:

   Stable sort needs backward loop [OK]

Hint: Place elements backward to keep stable order [OK]

Common Mistakes:

• Looping forward breaks stability
• Changing count array size unnecessarily
• Misunderstanding index calculation

5. You want to sort a list of strings representing numbers with varying lengths using Radix Sort in Go. Which approach correctly adapts Radix Sort for this case?

hard

A. Pad all strings with leading zeros to equal length, then sort digit by digit from right to left

B. Sort strings by length first, then apply Radix Sort on digits from left to right

C. Convert strings to integers and apply normal Radix Sort directly

D. Use Radix Sort only on the first character of each string

Solution

1. Step 1: Handle varying string lengths

   Pad strings with leading zeros so all have equal length, ensuring digit positions align.

2. Step 2: Apply Radix Sort digit by digit from right to left

   After padding, sort from least significant digit (rightmost) to most significant (leftmost) to maintain correct order.

3. Final Answer:

   Pad all strings with leading zeros to equal length, then sort digit by digit from right to left -> Option A

4. Quick Check:

   Padding equalizes length for Radix Sort [OK]

Hint: Pad strings to same length before sorting digits [OK]

Common Mistakes:

• Sorting by length first breaks digit alignment
• Converting strings to int may overflow or lose leading zeros
• Sorting only first character ignores full number