Add pigeonhole sort (TheAlgorithms#342)

Author: merelymyself

README.md

@@ -20,6 +20,7 @@ These are for demonstration purposes only.
 - [x] [Merge](./src/sorting/merge_sort.rs)
 - [x] [Odd-even](./src/sorting/odd_even_sort.rs)
 - [x] [Pancake](./src/sorting/pancake_sort.rs)
+- [x] [Pigeonhole](./src/sorting/pigeonhole_sort.rs)
 - [x] [Quick](./src/sorting/quick_sort.rs)
 - [x] [Radix](./src/sorting/radix_sort.rs)
 - [x] [Selection](./src/sorting/selection_sort.rs)

src/sorting/mod.rs

@@ -12,6 +12,7 @@ mod insertion_sort;
 mod merge_sort;
 mod odd_even_sort;
 mod pancake_sort;
+mod pigeonhole_sort;
 mod quick_sort;
 mod radix_sort;
 mod selection_sort;
@@ -34,6 +35,7 @@ pub use self::insertion_sort::insertion_sort;
 pub use self::merge_sort::merge_sort;
 pub use self::odd_even_sort::odd_even_sort;
 pub use self::pancake_sort::pancake_sort;
+pub use self::pigeonhole_sort::pigeonhole_sort;
 pub use self::quick_sort::{partition, quick_sort};
 pub use self::radix_sort::radix_sort;
 pub use self::selection_sort::selection_sort;

src/sorting/pigeonhole_sort.rs

@@ -0,0 +1,38 @@
+// From Wikipedia: Pigeonhole sorting is a sorting algorithm that is suitable for sorting lists of elements where the number of elements (n) and the length of the range of possible key values (N) are approximately the same. It requires O(n + N) time.
+
+pub fn pigeonhole_sort(array: &mut [i32]) {
+    if let (Some(min), Some(max)) = (array.iter().min(), array.iter().max()) {
+        let holes_range: usize = (max - min + 1) as usize;
+        let mut holes = vec![0; holes_range];
+        let mut holes_repeat = vec![0; holes_range];
+        for i in array.iter() {
+            let index = *i - min;
+            holes[index as usize] = *i;
+            holes_repeat[index as usize] += 1;
+        }
+        let mut index = 0;
+        for i in 0..holes_range {
+            while holes_repeat[i] > 0 {
+                array[index] = holes[i];
+                index += 1;
+                holes_repeat[i] -= 1;
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::is_sorted;
+    use super::*;
+
+    #[test]
+    fn test1() {
+        let mut arr1 = [3, 3, 3, 1, 2, 6, 5, 5, 5, 4, 1, 6, 3];
+        pigeonhole_sort(&mut arr1);
+        assert!(is_sorted(&arr1));
+        let mut arr2 = [6, 5, 4, 3, 2, 1];
+        pigeonhole_sort(&mut arr2);
+        assert!(is_sorted(&arr2));
+    }
+}