Add counting sort (#24)

Author: Emilien Fugier

src/sorting/counting_sort.rs

@@ -0,0 +1,87 @@
+/// In place counting sort for collections of u32
+/// O(n + maxval) in time, where maxval is the biggest value an input can possibly take
+/// O(maxval) in memory
+/// u32 is chosen arbitrarly, a counting sort probably should'nt be used on data that requires bigger types.
+use std::fmt::Debug;
+pub fn counting_sort(arr: &mut [u32], maxval: usize) {
+    let mut occurences: Vec<usize> = vec![0; maxval + 1];
+
+    for &data in arr.iter() {
+        occurences[data as usize] += 1;
+    }
+
+    let mut i = 0;
+    for (data, &number) in occurences.iter().enumerate() {
+        for _ in 0..number {
+            arr[i] = data as u32;
+            i += 1;
+        }
+    }
+}
+
+use std::ops::AddAssign;
+/// Generic implementation of a counting sort for all usigned types
+pub fn generic_counting_sort<T: Into<u64> + From<u8> + AddAssign + Copy + Debug>(
+    arr: &mut [T],
+    maxval: usize,
+) {
+    let mut occurences: Vec<usize> = vec![0; maxval + 1];
+
+    for &data in arr.iter() {
+        occurences[data.into() as usize] += 1;
+    }
+
+    // Current index in output array
+    let mut i = 0;
+
+    // current data point, necessary to be type-safe
+    let mut data = T::from(0);
+
+    // This will iterate from 0 to the largest data point in `arr`
+    // `number` contains the occurances of the data point `data`
+    for &number in occurences.iter() {
+        for _ in 0..number {
+            arr[i] = data;
+            i += 1;
+        }
+
+        data += T::from(1);
+    }
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn counting_sort() {
+        //descending
+        let mut ve1 = vec![6, 5, 4, 3, 2, 1];
+        super::counting_sort(&mut ve1, 6);
+        for i in 0..ve1.len() - 1 {
+            assert!(ve1[i] <= ve1[i + 1]);
+        }
+
+        //pre-sorted
+        let mut ve2 = vec![1, 2, 3, 4, 5, 6];
+        super::counting_sort(&mut ve2, 6);
+        for i in 0..ve2.len() - 1 {
+            assert!(ve2[i] <= ve2[i + 1]);
+        }
+    }
+    #[test]
+    fn generic_counting_sort() {
+        //descending u8
+        let mut ve1: Vec<u8> = vec![100, 30, 60, 10, 20, 120, 1];
+        super::generic_counting_sort(&mut ve1, 120);
+        println!("{:?}", ve1);
+        for i in 0..ve1.len() - 1 {
+            assert!(ve1[i] <= ve1[i + 1]);
+        }
+
+        //pre-sorted u64
+        let mut ve2: Vec<u64> = vec![1, 2, 3, 4, 5, 6];
+        super::generic_counting_sort(&mut ve2, 6);
+        for i in 0..ve2.len() - 1 {
+            assert!(ve2[i] <= ve2[i + 1]);
+        }
+    }
+}

src/sorting/mod.rs

@@ -1,7 +1,10 @@
 mod bubble_sort;
+mod counting_sort;
 mod insertion;
 mod quick_sort;
 
 pub use self::bubble_sort::bubble_sort;
+pub use self::counting_sort::counting_sort;
+pub use self::counting_sort::generic_counting_sort;
 pub use self::insertion::insertion_sort;
 pub use self::quick_sort::quick_sort;