Struct RadixSort

Source

pub struct RadixSort<T>where
    T: RadixSortable,
{ /* private fields */ }

Expand description

Universal Radix Sort implementation.

This struct provides a generic interface for sorting collections using the Radix Sort algorithm. It supports multiple data types including integers, floating-point numbers, and strings.

§Type Parameters

T - The type of elements to sort (must implement RadixSortable)

§Examples

use universal_radix_sort::{RadixSort, RadixDataType, SortDirection};

// Sort integers in ascending order
let mut numbers = vec![5, 2, 8, 1, 9];
let sorter = RadixSort::<i64>::new(RadixDataType::SignedInteger, SortDirection::Ascending);
sorter.sort(&mut numbers);
assert_eq!(numbers, vec![1, 2, 5, 8, 9]);

// Sort in descending order
let mut numbers = vec![5, 2, 8, 1, 9];
let sorter = RadixSort::<i64>::new(RadixDataType::SignedInteger, SortDirection::Descending);
sorter.sort(&mut numbers);
assert_eq!(numbers, vec![9, 8, 5, 2, 1]);

§Performance

Time Complexity: O(n·k) where n is the number of elements and k is the number of bytes
Space Complexity: O(n) for the temporary buffer

§Stability

Radix Sort is a stable sorting algorithm, meaning that equal elements maintain their relative order after sorting.

Implementations§

Source §

impl RadixSort<String>

Source

pub fn sort_strings_msd(&self, slice: &mut [String]) -> RadixResult<()>

MSD (Most Significant Digit) first radix sort for String.

This is more efficient for strings as it allows early termination when differences are found in higher-order characters.

§Arguments

slice - The mutable slice of Strings to sort

§Returns

Ok(()) on success, Err(RadixError) if sorting fails.

Source §

impl RadixSort<&str>

Source

pub fn sort_str_slice_msd(&self, slice: &mut [&str]) -> RadixResult<()>

MSD radix sort for &str slice.

§Arguments

slice - The mutable slice to sort

§Returns

Ok(()) on success.

Source §

impl<T> RadixSort<T>
where T: RadixSortable,

Source

pub fn new(data_type: RadixDataType, direction: SortDirection) -> Self

Creates a new RadixSort instance.

§Arguments

data_type - The data type category for sorting strategy selection
direction - The sort direction (ascending or descending)

§Returns

A new RadixSort instance configured with the specified parameters

§Examples

use universal_radix_sort::{RadixSort, RadixDataType, SortDirection};

let sorter = RadixSort::<i64>::new(
    RadixDataType::SignedInteger,
    SortDirection::Ascending,
);

Source

pub fn with_processing_order( data_type: RadixDataType, direction: SortDirection, processing_order: ProcessingOrder, ) -> Self

Creates a new RadixSort instance with custom processing order.

§Arguments

data_type - The data type category
direction - The sort direction
processing_order - The byte processing order

§Examples

use universal_radix_sort::{RadixSort, RadixDataType, SortDirection, ProcessingOrder};

let sorter = RadixSort::<String>::with_processing_order(
    RadixDataType::String,
    SortDirection::Ascending,
    ProcessingOrder::MsbFirst,
);

Source

pub fn sort(&self, slice: &mut [T]) -> RadixResult<()>

Sorts a mutable slice in-place.

This method modifies the input slice directly without allocating a new collection.

§Arguments

slice - The mutable slice to sort

§Returns

Ok(()) on success, Err(RadixError) if sorting fails

§Examples

use universal_radix_sort::{RadixSort, RadixDataType, SortDirection};

let mut numbers = vec![5, 2, 8, 1, 9];
let sorter = RadixSort::<i64>::new(RadixDataType::SignedInteger, SortDirection::Ascending);
sorter.sort(&mut numbers).unwrap();
assert_eq!(numbers, vec![1, 2, 5, 8, 9]);

§Performance

Allocates O(n) temporary buffer for stability
Does not allocate a new collection

Source

pub fn sort_to_vec(&self, collection: &[T]) -> RadixResult<Vec<T>>

Sorts a collection and returns a new sorted vector.

This method does not modify the input collection.

§Arguments

collection - The collection to sort

§Returns

A new sorted vector, or Err(RadixError) if sorting fails

§Examples

use universal_radix_sort::{RadixSort, RadixDataType, SortDirection};

let numbers = vec![5, 2, 8, 1, 9];
let sorter = RadixSort::<i64>::new(RadixDataType::SignedInteger, SortDirection::Ascending);
let sorted = sorter.sort_to_vec(&numbers).unwrap();
assert_eq!(sorted, vec![1, 2, 5, 8, 9]);
// Original is unchanged
assert_eq!(numbers, vec![5, 2, 8, 1, 9]);