Radix Sort Algorithm in DSA Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is Radix Sort?

Radix Sort is a sorting method that sorts numbers digit by digit, starting from the least significant digit to the most significant digit.

beginner

How does Radix Sort handle sorting of numbers?

It groups numbers by each digit using a stable sorting method, usually counting sort, and processes digits from right to left.

intermediate

Why is Radix Sort efficient for sorting integers?

Because it sorts numbers by digits and avoids comparisons, it can sort large lists of integers in linear time relative to the number of digits.

intermediate

What is the role of stable sorting in Radix Sort?

Stable sorting keeps the order of numbers with the same digit, which is essential to correctly sort by multiple digit positions.

intermediate

What is the time complexity of Radix Sort?

The time complexity is O(d * (n + k)) where d is the number of digits, n is the number of elements, and k is the range of digits (usually 10).

Which digit does Radix Sort start sorting from?

A Middle digit

B Least significant digit

C Most significant digit

D Random digit

Radix Sort processes digits starting from the least significant digit to the most significant digit.

What kind of sorting method is used inside Radix Sort for each digit?

A Stable sorting

B Unstable sorting

C Recursive sorting

D Random sorting

Radix Sort uses a stable sorting method like counting sort to maintain the order of equal digits.

Radix Sort is best suited for sorting which type of data?

A Linked lists only

B Floating point numbers

C Unstructured text

D Integers or fixed-length strings

Radix Sort works best with integers or fixed-length strings where digits or characters can be processed.

What is the main advantage of Radix Sort over comparison-based sorts?

A It uses less memory

B It is easier to implement

C It can sort in linear time relative to input size and digit count

D It sorts in place

Radix Sort can achieve linear time complexity depending on digit count, unlike comparison sorts which are O(n log n).

What does the 'd' represent in Radix Sort's time complexity O(d * (n + k))?

A Number of digits in the largest number

B Number of elements

C Range of digits

D Depth of recursion

'd' is the number of digits in the largest number to be sorted.

Explain how Radix Sort sorts a list of numbers step-by-step.

Think about sorting by each digit one at a time.

Describe why stable sorting is important in Radix Sort.

Consider what happens if order changes between digit passes.

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