Add Bingo Sort (#642)

DIRECTORY.md

@@ -65,6 +65,7 @@
       * [Count Min Sketch](https://github.com/TheAlgorithms/Rust/blob/master/src/data_structures/probabilistic/count_min_sketch.rs)
     * [Queue](https://github.com/TheAlgorithms/Rust/blob/master/src/data_structures/queue.rs)
     * [Rb Tree](https://github.com/TheAlgorithms/Rust/blob/master/src/data_structures/rb_tree.rs)
+    * [HashTable](https://github.com/TheAlgorithms/Rust/blob/master/src/data_structures/hash_table.rs)
     * [Segment Tree](https://github.com/TheAlgorithms/Rust/blob/master/src/data_structures/segment_tree.rs)
     * [Segment Tree Recursive](https://github.com/TheAlgorithms/Rust/blob/master/src/data_structures/segment_tree_recursive.rs)
     * [Stack Using Singly Linked List](https://github.com/TheAlgorithms/Rust/blob/master/src/data_structures/stack_using_singly_linked_list.rs)
@@ -139,7 +140,6 @@
     * [Two Satisfiability](https://github.com/TheAlgorithms/Rust/blob/master/src/graph/two_satisfiability.rs)
   * [Lib](https://github.com/TheAlgorithms/Rust/blob/master/src/lib.rs)
   * Machine Learning
-    * [Cholesky](https://github.com/TheAlgorithms/Rust/blob/master/src/machine_learning/cholesky.rs)
     * [K Means](https://github.com/TheAlgorithms/Rust/blob/master/src/machine_learning/k_means.rs)
     * [Linear Regression](https://github.com/TheAlgorithms/Rust/blob/master/src/machine_learning/linear_regression.rs)
     * Loss Function
@@ -148,7 +148,8 @@
     * Optimization
       * [Adam](https://github.com/TheAlgorithms/Rust/blob/master/src/machine_learning/optimization/adam.rs)
       * [Gradient Descent](https://github.com/TheAlgorithms/Rust/blob/master/src/machine_learning/optimization/gradient_descent.rs)
-    * [Simpson](https://github.com/TheAlgorithms/Rust/blob/master/src/machine_learning/simpson.rs)
+      * [Cholesky](https://github.com/TheAlgorithms/Rust/blob/master/src/machine_learning/cholesky.rs)
+      * [Simpson](https://github.com/TheAlgorithms/Rust/blob/master/src/machine_learning/simpson.rs)
   * Math
     * [Abs](https://github.com/TheAlgorithms/Rust/blob/master/src/math/abs.rs)
     * [Aliquot Sum](https://github.com/TheAlgorithms/Rust/blob/master/src/math/aliquot_sum.rs)
@@ -252,6 +253,7 @@
   * Sorting
     * [Bead Sort](https://github.com/TheAlgorithms/Rust/blob/master/src/sorting/bead_sort.rs)
     * [Binary Insertion Sort](https://github.com/TheAlgorithms/Rust/blob/master/src/sorting/binary_insertion_sort.rs)
+    * [Bingo Sort](https://github.com/TheAlgorithms/Rust/blob/master/src/sorting/bingo_sort.rs)
     * [Bitonic Sort](https://github.com/TheAlgorithms/Rust/blob/master/src/sorting/bitonic_sort.rs)
     * [Bogo Sort](https://github.com/TheAlgorithms/Rust/blob/master/src/sorting/bogo_sort.rs)
     * [Bubble Sort](https://github.com/TheAlgorithms/Rust/blob/master/src/sorting/bubble_sort.rs)

src/sorting/bingo_sort.rs

@@ -0,0 +1,105 @@
+use std::cmp::{max, min};
+
+// Function for finding the maximum and minimum element of the Array
+fn max_min(vec: &[i32], bingo: &mut i32, next_bingo: &mut i32) {
+    for &element in vec.iter().skip(1) {
+        *bingo = min(*bingo, element);
+        *next_bingo = max(*next_bingo, element);
+    }
+}
+
+pub fn bingo_sort(vec: &mut Vec<i32>) {
+    if vec.is_empty() {
+        return;
+    }
+
+    let mut bingo = vec[0];
+    let mut next_bingo = vec[0];
+
+    max_min(vec, &mut bingo, &mut next_bingo);
+
+    let largest_element = next_bingo;
+    let mut next_element_pos = 0;
+
+    for (bingo, _next_bingo) in (bingo..=largest_element).zip(bingo..=largest_element) {
+        let start_pos = next_element_pos;
+
+        for i in start_pos..vec.len() {
+            if vec[i] == bingo {
+                vec.swap(i, next_element_pos);
+                next_element_pos += 1;
+            }
+        }
+    }
+}
+
+#[allow(dead_code)]
+fn print_array(arr: &[i32]) {
+    print!("Sorted Array: ");
+    for &element in arr {
+        print!("{} ", element);
+    }
+    println!();
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_bingo_sort() {
+        let mut arr = vec![5, 4, 8, 5, 4, 8, 5, 4, 4, 4];
+        bingo_sort(&mut arr);
+        assert_eq!(arr, vec![4, 4, 4, 4, 4, 5, 5, 5, 8, 8]);
+
+        let mut arr2 = vec![10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
+        bingo_sort(&mut arr2);
+        assert_eq!(arr2, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+
+        let mut arr3 = vec![0, 1, 0, 1, 0, 1];
+        bingo_sort(&mut arr3);
+        assert_eq!(arr3, vec![0, 0, 0, 1, 1, 1]);
+    }
+
+    #[test]
+    fn test_empty_array() {
+        let mut arr = Vec::new();
+        bingo_sort(&mut arr);
+        assert_eq!(arr, Vec::new());
+    }
+
+    #[test]
+    fn test_single_element_array() {
+        let mut arr = vec![42];
+        bingo_sort(&mut arr);
+        assert_eq!(arr, vec![42]);
+    }
+
+    #[test]
+    fn test_negative_numbers() {
+        let mut arr = vec![-5, -4, -3, -2, -1];
+        bingo_sort(&mut arr);
+        assert_eq!(arr, vec![-5, -4, -3, -2, -1]);
+    }
+
+    #[test]
+    fn test_already_sorted() {
+        let mut arr = vec![1, 2, 3, 4, 5];
+        bingo_sort(&mut arr);
+        assert_eq!(arr, vec![1, 2, 3, 4, 5]);
+    }
+
+    #[test]
+    fn test_reverse_sorted() {
+        let mut arr = vec![5, 4, 3, 2, 1];
+        bingo_sort(&mut arr);
+        assert_eq!(arr, vec![1, 2, 3, 4, 5]);
+    }
+
+    #[test]
+    fn test_duplicates() {
+        let mut arr = vec![1, 2, 3, 4, 5, 1, 2, 3, 4, 5];
+        bingo_sort(&mut arr);
+        assert_eq!(arr, vec![1, 1, 2, 2, 3, 3, 4, 4, 5, 5]);
+    }
+}

src/sorting/mod.rs

@@ -1,5 +1,6 @@
 mod bead_sort;
 mod binary_insertion_sort;
+mod bingo_sort;
 mod bitonic_sort;
 mod bogo_sort;
 mod bubble_sort;
@@ -35,6 +36,7 @@ mod wiggle_sort;
 
 pub use self::bead_sort::bead_sort;
 pub use self::binary_insertion_sort::binary_insertion_sort;
+pub use self::bingo_sort::bingo_sort;
 pub use self::bitonic_sort::bitonic_sort;
 pub use self::bogo_sort::bogo_sort;
 pub use self::bubble_sort::bubble_sort;