#sorting #sort #radix #counting

no-std radsort

Radix sort implementation for sorting by scalar keys (integers, floats, chars, bools)

2 unstable releases

0.1.0 Apr 12, 2020
0.0.0 Apr 8, 2020

#349 in Algorithms

Download history 6895/week @ 2022-11-29 8433/week @ 2022-12-06 5521/week @ 2022-12-13 6915/week @ 2022-12-20 5913/week @ 2022-12-27 7221/week @ 2023-01-03 8112/week @ 2023-01-10 9166/week @ 2023-01-17 9862/week @ 2023-01-24 10218/week @ 2023-01-31 9658/week @ 2023-02-07 12119/week @ 2023-02-14 10673/week @ 2023-02-21 11403/week @ 2023-02-28 12770/week @ 2023-03-07 8804/week @ 2023-03-14

45,291 downloads per month
Used in 360 crates (3 directly)

MIT/Apache

48KB
521 lines

radsort

Crates.io Docs

radsort is a radix sort implementation for sorting by scalar keys (integers, floats, chars, bools).

All built-in scalar types can be used as sorting keys: Booleans, characters, integers, and floating point-numbers. To sort by multiple keys, put them in a tuple, starting from the most significant key. See Key for a full list of supported keys.

  • best and worst-case running time is O(n) – see benchmarks for more detailed performance characteristics
  • space complexity is O(n) – allocates temporary storage the size of the slice, for indirect sort see sort_by_cached_key
  • stable, i.e. does not reorder equal elements
  • uses #![no_std], but needs an allocator

This sort can be several times faster than slice::sort and slice::sort_unstable, typically on large slices (hundreds of elements or more). It performs worse on short slices and when using wide keys (16 bytes). See benchmarks to get a better picture of the performance characteristics.

radsort is an implementation of LSB radix sort, using counting sort to sort the slice by each digit (byte) of the key. As an optimization, the slice is sorted only by digits which differ between the keys. See the unopt module for more details and functions which don't use this optimization.

This implementation is based on radix sort by Pierre Terdiman, published at http://codercorner.com/RadixSortRevisited.htm, with select optimizations published by Michael Herf at http://stereopsis.com/radix.html.

Floating-point numbers

Floating-point number keys are effectively sorted according to their partial order (see PartialOrd), with NaN values at the beginning (before the negative infinity) and at the end (after the positive infinity), depending on the sign bit of each NaN.

Examples

Slices of scalar types (integers, floating-point numbers, Booleans, and characters) can be sorted directly:

let mut data = [2i32, -1, 1, 0, -2];

radsort::sort(&mut data);

assert_eq!(data, [-2, -1, 0, 1, 2]);

Use a key extraction function to sort other types:

let mut friends = ["Punchy", "Isabelle", "Sly", "Puddles", "Gladys"];

// sort by the length of the string in bytes
radsort::sort_by_key(&mut friends, |s| s.len());

assert_eq!(friends, ["Sly", "Punchy", "Gladys", "Puddles", "Isabelle"]);

To sort by two or more keys, put them in a tuple, starting with the most significant key:

struct Height { feet: u8, inches: u8, }

let mut heights = [
    Height { feet: 6, inches: 1 },
    Height { feet: 5, inches: 9 },
    Height { feet: 6, inches: 0 },
];

// sort by feet, if feet are equal, sort by inches
radsort::sort_by_key(&mut heights, |h| (h.feet, h.inches));

assert_eq!(heights, [
    Height { feet: 5, inches: 9 },
    Height { feet: 6, inches: 0 },
    Height { feet: 6, inches: 1 },
]);

No runtime deps