Radix Sort Algorithm in DSA Rust - Build from Scratch

Radix Sort Algorithm

📖 Scenario: You are working on a system that needs to sort a list of positive integers quickly and efficiently. Radix Sort is a great choice because it sorts numbers digit by digit, starting from the least significant digit.Imagine you have a list of product IDs that need to be sorted before processing.

🎯 Goal: Build a Radix Sort function in Rust that sorts a list of positive integers in ascending order.

📋 What You'll Learn

Create a vector called numbers with the exact values: 170, 45, 75, 90, 802, 24, 2, 66

Create a variable called max_num that stores the maximum number in numbers

Implement the core Radix Sort logic using a loop over digit places and buckets

Print the sorted numbers vector at the end

💡 Why This Matters

🌍 Real World

Radix Sort is used in systems where sorting large lists of numbers quickly is important, such as database indexing, digital signal processing, and large-scale data processing.

💼 Career

Understanding Radix Sort helps in roles involving algorithm optimization, data engineering, and software development where efficient sorting is critical.

1

Create the initial list of numbers

Create a vector called numbers with these exact values: 170, 45, 75, 90, 802, 24, 2, 66

DSA Rust

# Create the vector numbers with the given values
# Your code here

Hint

Use let mut numbers = vec![170, 45, 75, 90, 802, 24, 2, 66]; to create the vector.

2

Find the maximum number in the list

Create a variable called max_num that stores the maximum number in the numbers vector using iter().max() and unwrap()

DSA Rust

fn main() {
    let mut numbers = vec![170, 45, 75, 90, 802, 24, 2, 66];
    // Find the maximum number in numbers
    // Your code here
}

Hint

Use let max_num = *numbers.iter().max().unwrap(); to get the maximum number.

3

Implement the Radix Sort core logic

Implement the Radix Sort logic by creating a place variable starting at 1, then use a while loop that runs while max_num / place > 0. Inside the loop, create 10 buckets as vectors, distribute numbers based on the digit at place, then flatten buckets back into numbers. Multiply place by 10 at the end of each loop.

DSA Rust

fn main() {
    let mut numbers = vec![170, 45, 75, 90, 802, 24, 2, 66];
    let max_num = *numbers.iter().max().unwrap();

    // Implement Radix Sort logic here
    // Your code here
}

Hint

Use a while loop with place starting at 1. Create 10 buckets as vectors. Distribute numbers by digit, then collect them back. Multiply place by 10 each time.

4

Print the sorted numbers

Print the sorted numbers vector using println!("{:?}", numbers);

DSA Rust

fn main() {
    let mut numbers = vec![170, 45, 75, 90, 802, 24, 2, 66];
    let max_num = *numbers.iter().max().unwrap();

    let mut place = 1;
    while max_num / place > 0 {
        let mut buckets: Vec> = vec![Vec::new(); 10];

        for &num in &numbers {
            let digit = (num / place) % 10;
            buckets[digit as usize].push(num);
        }

        numbers.clear();
        for bucket in buckets.iter() {
            for &num in bucket {
                numbers.push(num);
            }
        }

        place *= 10;
    }

    // Print the sorted numbers
    // Your code here
}

Hint

Use println!("{:?}", numbers); to print the sorted vector.

Practice

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

easy

A. Sort numbers by swapping adjacent elements repeatedly

B. Sort numbers by comparing each pair directly

C. Sort numbers by dividing them into two halves recursively

D. Sort numbers digit by digit starting from the least significant digit

Solution

1. Step 1: Understand Radix Sort approach

   Radix sort sorts numbers by processing each digit separately, starting from the least significant digit (rightmost).

2. Step 2: Compare with other sorting methods

   Unlike comparison-based sorts, radix sort uses digit positions to sort without direct element comparisons.

3. Final Answer:

   Sort numbers digit by digit starting from the least significant digit -> Option D

4. Quick Check:

   Radix sort = digit-by-digit sorting [OK]

Hint: Radix sort processes digits from right to left [OK]

Common Mistakes:

• Thinking radix sort compares elements directly
• Assuming it sorts by dividing arrays recursively
• Confusing it with bubble or quick sort methods

2. Which of the following Rust code snippets correctly initializes a vector to hold buckets for digits 0 to 9 in radix sort?

easy

A. let mut buckets: Vec = vec![Vec::new(); 10];

B. let buckets = Vec::with_capacity(10);

C. let buckets: Vec<i32> = vec![0; 10];

D. let mut buckets = vec![0; 10];

Solution

1. Step 1: Understand bucket structure needed

   Radix sort uses buckets as vectors of vectors to hold numbers for each digit (0-9).

2. Step 2: Check Rust syntax for initializing vector of vectors

   Using vec![Vec::new(); 10] creates 10 empty vectors, one for each digit bucket.

3. Final Answer:

   let mut buckets: Vec = vec![Vec::new(); 10]; -> Option A

4. Quick Check:

   Vector of vectors for buckets = let mut buckets: Vec = vec![Vec::new(); 10]; [OK]

Hint: Buckets need vectors inside a vector, not just integers [OK]

Common Mistakes:

• Using Vec<i32> instead of Vec for buckets
• Using with_capacity without initializing inner vectors
• Initializing buckets as integers instead of vectors

3. What will be the output of the following Rust code snippet implementing one pass of radix sort on the least significant digit?

let arr = vec![170, 45, 75, 90, 802, 24, 2, 66];
let mut buckets: Vec = vec![Vec::new(); 10];
for &num in &arr {
    let digit = num % 10;
    buckets[digit as usize].push(num);
}
let mut result = Vec::new();
for bucket in buckets {
    for num in bucket {
        result.push(num);
    }
}
println!("{:?}", result);

medium

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

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

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

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

Solution

1. Step 1: Calculate least significant digit for each number

   Digits: 170%10=0, 45%10=5, 75%10=5, 90%10=0, 802%10=2, 24%10=4, 2%10=2, 66%10=6.

2. Step 2: Place numbers in buckets and flatten

   Buckets: 0->[170,90], 2->[802,2], 4->[24], 5->[45,75], 6->[66]. Flattening in order: [170, 90, 802, 2, 24, 45, 75, 66].

3. Final Answer:

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

4. Quick Check:

   Sorted by least digit = [170, 90, 802, 2, 24, 45, 75, 66] [OK]

Hint: Check digit % 10 and group accordingly [OK]

Common Mistakes:

• Mixing up digit extraction with division
• Not preserving order within buckets
• Incorrectly flattening buckets

4. Identify the bug in this Rust code snippet for one pass of radix sort and choose the fix:

let arr = vec![170, 45, 75];
let mut buckets: Vec = vec![Vec::new(); 10];
for num in arr {
    let digit = num / 10 % 10;
    buckets[digit].push(num);
}

medium

A. Change buckets[digit] to buckets[digit as usize]

B. Change num / 10 % 10 to num % 10

C. Initialize buckets with vec![0; 10] instead of vectors

D. Use for &num in &arr instead of for num in arr

Solution

1. Step 1: Identify type mismatch in indexing

   Variable digit is an integer but Rust requires usize for vector indexing.

2. Step 2: Fix by casting digit to usize

   Use buckets[digit as usize] to correctly index the vector.

3. Final Answer:

   Change buckets[digit] to buckets[digit as usize] -> Option A

4. Quick Check:

   Vector index must be usize = Change buckets[digit] to buckets[digit as usize] [OK]

Hint: Vector indices in Rust must be usize type [OK]

Common Mistakes:

• Using integer directly as vector index without casting
• Changing digit calculation unnecessarily
• Incorrect bucket initialization

5. Given the Rust function below that performs radix sort on a vector of positive integers, what will be the final sorted vector?

fn radix_sort(mut arr: Vec<i32>) -> Vec<i32> {
    let max = *arr.iter().max().unwrap();
    let mut exp = 1;
    while max / exp > 0 {
        let mut buckets: Vec = vec![Vec::new(); 10];
        for &num in &arr {
            let digit = (num / exp) % 10;
            buckets[digit as usize].push(num);
        }
        arr.clear();
        for bucket in buckets {
            for num in bucket {
                arr.push(num);
            }
        }
        exp *= 10;
    }
    arr
}

let input = vec![329, 457, 657, 839, 436, 720, 355];
let sorted = radix_sort(input);
println!("{:?}", sorted);

hard

A. [329, 436, 355, 457, 657, 720, 839]

B. [839, 720, 657, 457, 436, 355, 329]

C. [329, 355, 436, 457, 657, 720, 839]

D. [355, 329, 436, 457, 657, 720, 839]

Solution

1. Step 1: Understand the radix sort passes

   The function sorts by digits starting from least significant (units), then tens, then hundreds until max digit processed.

2. Step 2: Trace sorting steps on input

   After all passes, the vector is sorted ascending: [329, 355, 436, 457, 657, 720, 839].

3. Final Answer:

   [329, 355, 436, 457, 657, 720, 839] -> Option C

4. Quick Check:

   Radix sort final output = sorted ascending [OK]

Hint: Radix sort outputs fully sorted list ascending [OK]

Common Mistakes:

• Confusing order as descending
• Missing clearing array before collecting buckets
• Not multiplying exp by 10 each iteration