feat: make sorting mods consistent + misc minor fixes (alexfertel#61)

Co-authored-by: Alexander González <[email protected]>

Author: CodingTil

Cargo.toml

@@ -6,3 +6,4 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+paste = "1.0.12"

src/sorting/bogo_sort.rs

@@ -1,65 +1,76 @@
-use super::traits::MutableSorter;
 use crate::math::PCG32;
+use crate::sorting::traits::Sorter;
 use std::time::{SystemTime, UNIX_EPOCH};
 
-const DEFAULT: u64 = 4294967296;
+const DEFAULT: u64 = 2 << 31; // 2^32
 
-pub struct BogoSort;
+fn is_sorted<T: Ord>(arr: &[T], len: usize) -> bool {
+    if len <= 1 {
+        return true;
+    }
 
-impl BogoSort {
-    fn is_sorted<T: Ord>(arr: &[T], len: usize) -> bool {
-        for i in 0..len - 1 {
-            if arr[i] > arr[i + 1] {
-                return false;
-            }
+    for i in 0..len - 1 {
+        if arr[i] > arr[i + 1] {
+            return false;
         }
-
-        true
-    }
-    #[cfg(target_pointer_width = "64")]
-    fn generate_index(range: usize, generator: &mut PCG32) -> usize {
-        generator.get_u64() as usize % range
     }
 
-    #[cfg(not(target_pointer_width = "64"))]
-    fn generate_index(range: usize, generator: &mut PCG32) -> usize {
-        generator.get_u32() as usize % range
+    true
+}
+#[cfg(target_pointer_width = "64")]
+fn generate_index(range: usize, generator: &mut PCG32) -> usize {
+    generator.get_u64() as usize % range
+}
+
+#[cfg(not(target_pointer_width = "64"))]
+fn generate_index(range: usize, generator: &mut PCG32) -> usize {
+    generator.get_u32() as usize % range
+}
+
+/**
+ * Fisher–Yates shuffle for generating random permutation.
+ */
+fn permute_randomly<T>(arr: &mut [T], len: usize, generator: &mut PCG32) {
+    if len <= 1 {
+        return;
     }
 
-    /**
-     * Fisher–Yates shuffle for generating random permutation.
-     */
-    fn permute_randomly<T>(arr: &mut [T], len: usize, generator: &mut PCG32) {
-        for i in (1..len).rev() {
-            let j = BogoSort::generate_index(i + 1, generator);
-            arr.swap(i, j);
-        }
+    for i in (1..len).rev() {
+        let j = generate_index(i + 1, generator);
+        arr.swap(i, j);
     }
 }
 
-impl<T> MutableSorter<T> for BogoSort {
-    fn sort(arr: &mut [T])
-    where
-        T: Ord,
-    {
-        let seed = match SystemTime::now().duration_since(UNIX_EPOCH) {
-            Ok(duration) => duration.as_millis() as u64,
-            Err(_) => DEFAULT,
-        };
+fn bogo_sort<T: Ord>(arr: &mut [T]) {
+    let seed = match SystemTime::now().duration_since(UNIX_EPOCH) {
+        Ok(duration) => duration.as_millis() as u64,
+        Err(_) => DEFAULT,
+    };
 
-        let mut random_generator = PCG32::new_default(seed);
+    let mut random_generator = PCG32::new_default(seed);
 
-        let arr_length = arr.len();
-        while !BogoSort::is_sorted(arr, arr_length) {
-            BogoSort::permute_randomly(arr, arr_length, &mut random_generator);
-        }
+    let arr_length = arr.len();
+    while !is_sorted(arr, arr_length) {
+        permute_randomly(arr, arr_length, &mut random_generator);
+    }
+}
+
+pub struct BogoSort;
+
+impl<T> Sorter<T> for BogoSort
+where
+    T: Ord + Copy,
+{
+    fn sort_inplace(arr: &mut [T]) {
+        bogo_sort(arr);
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::super::traits::MutableSorter;
-    use super::BogoSort;
+    use crate::sorting::traits::Sorter;
+    use crate::sorting::BogoSort;
 
-    sorting_tests!(BogoSort::sort, inplace);
+    sorting_tests!(BogoSort::sort, bogo_sort);
+    sorting_tests!(BogoSort::sort_inplace, bogo_sort, inplace);
 }

src/sorting/bubble_sort.rs

@@ -1,31 +1,37 @@
-// It sorts the array by repeatedly comparing the
-// adjacent elements and swapping them if they are
-// in the wrong order.
-// Time complexity is O(N^2)
-// Auxiliary space is O(1)
-use super::traits::MutableSorter;
+use crate::sorting::traits::Sorter;
 
-pub struct BubbleSort;
-
-impl<T> MutableSorter<T> for BubbleSort {
-    fn sort(array: &mut [T])
-    where
-        T: Ord,
-    {
-        for i in 0..array.len() {
-            // Last i elements are already in place.
-            for j in 0..array.len() - 1 - i {
-                if array[j] > array[j + 1] {
-                    array.swap(j, j + 1);
-                }
+fn bubble_sort<T: Ord>(arr: &mut [T]) {
+    for i in 0..arr.len() {
+        // Last i elements are already in place.
+        for j in 0..arr.len() - 1 - i {
+            if arr[j] > arr[j + 1] {
+                arr.swap(j, j + 1);
             }
         }
     }
 }
 
+/// It sorts the array by repeatedly comparing the
+/// adjacent elements and swapping them if they are
+/// in the wrong order.
+/// Time complexity is O(N^2)
+/// Auxiliary space is O(1)
+pub struct BubbleSort;
+
+impl<T> Sorter<T> for BubbleSort
+where
+    T: Ord + Copy,
+{
+    fn sort_inplace(array: &mut [T]) {
+        bubble_sort(array);
+    }
+}
+
 #[cfg(test)]
 mod tests {
-    use super::super::traits::MutableSorter;
-    use super::BubbleSort;
-    sorting_tests!(BubbleSort::sort, inplace);
+    use crate::sorting::traits::Sorter;
+    use crate::sorting::BubbleSort;
+
+    sorting_tests!(BubbleSort::sort, bubble_sort);
+    sorting_tests!(BubbleSort::sort_inplace, bubble_sort, inplace);
 }

src/sorting/bucket_sort.rs

@@ -1,61 +1,54 @@
-/// Sort a slice using bucket sort algorithm.
-///
-/// Time complexity is `O(n + k)` on average, where `n` is the number of elements,
-/// `k` is the number of buckets used in process.
-///
-/// Space complexity is `O(n + k)`, as it sorts not in-place.
-pub fn bucket_sort(arr: &[usize]) -> Vec<usize> {
+use crate::sorting::insertion_sort::InsertionSort;
+use crate::sorting::traits::Sorter;
+
+fn bucket_sort<T: Ord + Copy + Into<usize>>(arr: &mut [T]) {
     if arr.is_empty() {
-        return vec![];
+        return;
     }
 
     let max = *arr.iter().max().unwrap();
     let len = arr.len();
     let mut buckets = vec![vec![]; len + 1];
 
-    for x in arr {
-        buckets[len * *x / max].push(*x);
+    for x in arr.iter() {
+        buckets[len * (*x).into() / max.into()].push(*x);
     }
 
     for bucket in buckets.iter_mut() {
-        super::insertion_sort(bucket);
+        InsertionSort::sort_inplace(bucket);
     }
 
-    let mut result = vec![];
+    let mut i = 0;
     for bucket in buckets {
         for x in bucket {
-            result.push(x);
+            arr[i] = x;
+            i += 1;
         }
     }
+}
 
-    result
+/// Sort a slice using bucket sort algorithm.
+///
+/// Time complexity is `O(n + k)` on average, where `n` is the number of elements,
+/// `k` is the number of buckets used in process.
+///
+/// Space complexity is `O(n + k)`, as it sorts not in-place.
+pub struct BucketSort;
+
+impl<T> Sorter<T> for BucketSort
+where
+    T: Ord + Copy + Into<usize>,
+{
+    fn sort_inplace(arr: &mut [T]) {
+        bucket_sort(arr);
+    }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::super::is_sorted;
-    use super::*;
-
-    sorting_tests!(bucket_sort);
+    use crate::sorting::traits::Sorter;
+    use crate::sorting::BucketSort;
 
-    #[test]
-    fn empty() {
-        let arr: [usize; 0] = [];
-        let res = bucket_sort(&arr);
-        assert!(is_sorted(&res));
-    }
-
-    #[test]
-    fn one_element() {
-        let arr: [usize; 1] = [4];
-        let res = bucket_sort(&arr);
-        assert!(is_sorted(&res));
-    }
-
-    #[test]
-    fn odd_number_of_elements() {
-        let arr: Vec<usize> = vec![1, 21, 5, 11, 58];
-        let res = bucket_sort(&arr);
-        assert!(is_sorted(&res));
-    }
+    sorting_tests!(BucketSort::sort, bucket_sort);
+    sorting_tests!(BucketSort::sort_inplace, bucket_sort, inplace);
 }

src/sorting/cocktail_shaker_sort.rs

@@ -1,4 +1,6 @@
-pub fn cocktail_shaker_sort<T: Ord>(arr: &mut [T]) {
+use crate::sorting::traits::Sorter;
+
+fn cocktail_shaker_sort<T: Ord>(arr: &mut [T]) {
     let len = arr.len();
 
     if len == 0 {
@@ -34,23 +36,26 @@ pub fn cocktail_shaker_sort<T: Ord>(arr: &mut [T]) {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    sorting_tests!(cocktail_shaker_sort, inplace);
+pub struct CocktailShakerSort;
 
-    #[test]
-    fn empty() {
-        let mut arr = Vec::<i32>::new();
-        cocktail_shaker_sort(&mut arr);
-        assert_eq!(arr, vec![]);
+impl<T> Sorter<T> for CocktailShakerSort
+where
+    T: Ord + Copy,
+{
+    fn sort_inplace(arr: &mut [T]) {
+        cocktail_shaker_sort(arr);
     }
+}
 
-    #[test]
-    fn one_element() {
-        let mut arr = vec![1];
-        cocktail_shaker_sort(&mut arr);
-        assert_eq!(arr, vec![1]);
-    }
+#[cfg(test)]
+mod tests {
+    use crate::sorting::traits::Sorter;
+    use crate::sorting::CocktailShakerSort;
+
+    sorting_tests!(CocktailShakerSort::sort, cocktail_shaker_sort);
+    sorting_tests!(
+        CocktailShakerSort::sort_inplace,
+        cocktail_shaker_sort,
+        inplace
+    );
 }