Fix bitonic and binary_insertion sorts (TheAlgorithms#563)

Author: suzp1984

DIRECTORY.md

@@ -10,6 +10,8 @@
     * [Fast Factorial](https://github.com/TheAlgorithms/Rust/blob/master/src/big_integer/fast_factorial.rs)
     * [Hello Bigmath](https://github.com/TheAlgorithms/Rust/blob/master/src/big_integer/hello_bigmath.rs)
     * [Poly1305](https://github.com/TheAlgorithms/Rust/blob/master/src/big_integer/poly1305.rs)
+  * Bit Manipulation
+    * [Counting Bits](https://github.com/TheAlgorithms/Rust/blob/master/src/bit_manipulation/counting_bits.rs)
   * Ciphers
     * [Aes](https://github.com/TheAlgorithms/Rust/blob/master/src/ciphers/aes.rs)
     * [Another Rot13](https://github.com/TheAlgorithms/Rust/blob/master/src/ciphers/another_rot13.rs)
@@ -42,6 +44,7 @@
     * [B Tree](https://github.com/TheAlgorithms/Rust/blob/master/src/data_structures/b_tree.rs)
     * [Binary Search Tree](https://github.com/TheAlgorithms/Rust/blob/master/src/data_structures/binary_search_tree.rs)
     * [Fenwick Tree](https://github.com/TheAlgorithms/Rust/blob/master/src/data_structures/fenwick_tree.rs)
+    * [Floyds Algorithm](https://github.com/TheAlgorithms/Rust/blob/master/src/data_structures/floyds_algorithm.rs)
     * [Graph](https://github.com/TheAlgorithms/Rust/blob/master/src/data_structures/graph.rs)
     * [Heap](https://github.com/TheAlgorithms/Rust/blob/master/src/data_structures/heap.rs)
     * [Infix To Postfix](https://github.com/TheAlgorithms/Rust/blob/master/src/data_structures/infix_to_postfix.rs)
@@ -154,6 +157,7 @@
     * [Interpolation](https://github.com/TheAlgorithms/Rust/blob/master/src/math/interpolation.rs)
     * [Karatsuba Multiplication](https://github.com/TheAlgorithms/Rust/blob/master/src/math/karatsuba_multiplication.rs)
     * [Lcm Of N Numbers](https://github.com/TheAlgorithms/Rust/blob/master/src/math/lcm_of_n_numbers.rs)
+    * [Leaky Relu](https://github.com/TheAlgorithms/Rust/blob/master/src/math/leaky_relu.rs)
     * [Linear Sieve](https://github.com/TheAlgorithms/Rust/blob/master/src/math/linear_sieve.rs)
     * [Matrix Ops](https://github.com/TheAlgorithms/Rust/blob/master/src/math/matrix_ops.rs)
     * [Mersenne Primes](https://github.com/TheAlgorithms/Rust/blob/master/src/math/mersenne_primes.rs)
@@ -174,6 +178,8 @@
     * [Signum](https://github.com/TheAlgorithms/Rust/blob/master/src/math/signum.rs)
     * [Simpson Integration](https://github.com/TheAlgorithms/Rust/blob/master/src/math/simpson_integration.rs)
     * [Sine](https://github.com/TheAlgorithms/Rust/blob/master/src/math/sine.rs)
+    * [Softmax](https://github.com/TheAlgorithms/Rust/blob/master/src/math/softmax.rs)
+    * [Sprague Grundy Theorem](https://github.com/TheAlgorithms/Rust/blob/master/src/math/sprague_grundy_theorem.rs)
     * [Square Pyramidal Numbers](https://github.com/TheAlgorithms/Rust/blob/master/src/math/square_pyramidal_numbers.rs)
     * [Square Root](https://github.com/TheAlgorithms/Rust/blob/master/src/math/square_root.rs)
     * [Sum Of Digits](https://github.com/TheAlgorithms/Rust/blob/master/src/math/sum_of_digits.rs)
@@ -197,6 +203,7 @@
     * [Kth Smallest Heap](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/kth_smallest_heap.rs)
     * [Linear Search](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/linear_search.rs)
     * [Quick Select](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/quick_select.rs)
+    * [Saddleback Search](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/saddleback_search.rs)
     * [Ternary Search](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/ternary_search.rs)
     * [Ternary Search Min Max](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/ternary_search_min_max.rs)
     * [Ternary Search Min Max Recursive](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/ternary_search_min_max_recursive.rs)

src/sorting/binary_insertion_sort.rs

@@ -1,4 +1,4 @@
-fn binary_search<T: Ord>(arr: &[T], target: &T) -> usize {
+fn _binary_search<T: Ord>(arr: &[T], target: &T) -> usize {
     let mut low = 0;
     let mut high = arr.len();
 
@@ -15,19 +15,18 @@ fn binary_search<T: Ord>(arr: &[T], target: &T) -> usize {
     low
 }
 
-fn binary_insertion_sort<T: Ord + Clone>(arr: &mut [T]) {
+pub fn binary_insertion_sort<T: Ord + Clone>(arr: &mut [T]) {
     let len = arr.len();
 
     for i in 1..len {
         let key = arr[i].clone();
-        let index = binary_search(&arr[..i], &key);
-        
-        arr[index..i+1].rotate_right(1);
+        let index = _binary_search(&arr[..i], &key);
+
+        arr[index..i + 1].rotate_right(1);
         arr[index] = key;
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/sorting/bitonic_sort.rs

@@ -1,42 +1,43 @@
-pub fn comp_and_swap<T: Ord>(array: &mut [T], index1: i32, index2: i32, direction: i32) {
-    if (direction == 1 && array[index1 as usize] > array[index2 as usize])
-        || (direction == 0 && array[index1 as usize] < array[index2 as usize])
-    {
-        array.swap(index1 as usize, index2 as usize);
+fn _comp_and_swap<T: Ord>(array: &mut [T], left: usize, right: usize, ascending: bool) {
+    if (ascending && array[left] > array[right]) || (!ascending && array[left] < array[right]) {
+        array.swap(left, right);
     }
 }
 
-pub fn bitonic_merge<T: Ord>(array: &mut [T], low: i32, length: i32, direction: i32) {
+fn _bitonic_merge<T: Ord>(array: &mut [T], low: usize, length: usize, ascending: bool) {
     if length > 1 {
         let middle = length / 2;
         for i in low..(low + middle) {
-            comp_and_swap(array, i, i + middle, direction);
+            _comp_and_swap(array, i, i + middle, ascending);
         }
-        bitonic_merge(array, low, middle, direction);
-        bitonic_merge(array, low + middle, middle, direction);
+        _bitonic_merge(array, low, middle, ascending);
+        _bitonic_merge(array, low + middle, middle, ascending);
     }
 }
 
-pub fn bitonic_sort<T: Ord>(array: &mut [T], low: i32, length: i32, direction: i32) {
+pub fn bitonic_sort<T: Ord>(array: &mut [T], low: usize, length: usize, ascending: bool) {
     if length > 1 {
         let middle = length / 2;
-        bitonic_sort(array, low, middle, 1);
-        bitonic_sort(array, low + middle, middle, 0);
-        bitonic_merge(array, low, length, direction);
+        bitonic_sort(array, low, middle, true);
+        bitonic_sort(array, low + middle, middle, false);
+        _bitonic_merge(array, low, length, ascending);
     }
 }
 
 //Note that this program works only when size of input is a power of 2.
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::sorting::have_same_elements;
+    use crate::sorting::is_descending_sorted;
+    use crate::sorting::is_sorted;
 
     #[test]
     fn descending() {
         //descending
         let mut ve1 = vec![6, 5, 4, 3];
         let cloned = ve1.clone();
-        bitonic_sort(&mut ve1, 0, 4, 1);
+        bitonic_sort(&mut ve1, 0, 4, true);
         assert!(is_sorted(&ve1) && have_same_elements(&ve1, &cloned));
     }
 
@@ -45,7 +46,7 @@ mod tests {
         //pre-sorted
         let mut ve2 = vec![1, 2, 3, 4];
         let cloned = ve2.clone();
-        bitonic_sort(&mut ve2, 0, 4, 0);
-        assert!(is_sorted(&ve2) && have_same_elements(&ve2, &cloned));
+        bitonic_sort(&mut ve2, 0, 4, false);
+        assert!(is_descending_sorted(&ve2) && have_same_elements(&ve2, &cloned));
     }
 }

src/sorting/mod.rs

@@ -1,4 +1,6 @@
 mod bead_sort;
+mod binary_insertion_sort;
+mod bitonic_sort;
 mod bogo_sort;
 mod bubble_sort;
 mod bucket_sort;
@@ -28,6 +30,8 @@ mod stooge_sort;
 mod tim_sort;
 
 pub use self::bead_sort::bead_sort;
+pub use self::binary_insertion_sort::binary_insertion_sort;
+pub use self::bitonic_sort::bitonic_sort;
 pub use self::bogo_sort::bogo_sort;
 pub use self::bubble_sort::bubble_sort;
 pub use self::bucket_sort::bucket_sort;
@@ -90,6 +94,14 @@ where
     arr.windows(2).all(|w| w[0] <= w[1])
 }
 
+#[cfg(test)]
+pub fn is_descending_sorted<T>(arr: &[T]) -> bool
+where
+    T: cmp::PartialOrd,
+{
+    arr.windows(2).all(|w| w[0] >= w[1])
+}
+
 #[cfg(test)]
 mod tests {
     #[test]