completed merge_sort

src/bubble_sort.rs

@@ -43,14 +43,12 @@ mod tests {
         assert_eq!(arr, [42]);
     }
 }
-pub fn bubble_sort(arr: &mut [usize]) {
+pub fn bubble_sort<T: Ord>(arr: &mut [T]) {
     let n = arr.len();
     for i in 0..n {
         for j in 0..n - 1 - i {
             if arr[j] > arr[j + 1] {
-                let tmp = arr[j];
-                arr[j] = arr[j + 1];
-                arr[j + 1] = tmp;
+                arr.swap(j, j + 1);
             }
         }
     }

src/dijkstras.rs

@@ -1,6 +1,7 @@
 use crate::data_structures::{weighted_adj_list::WeightedAdjacencyList,min_heap::MinHeap};
 #[cfg(test)]
 mod tests {
+    use crate::data_structures::weighted_adj_list::WeightedAdjacencyList;
     use super::dijkstras_shortest_path;
     #[test]
     fn dijkstras_shortest_path_primeagen_class_test(){

src/heap_sort.rs

@@ -0,0 +1,3 @@
+pub fn heap_sort(){
+    
+}

src/merge_sort.rs

@@ -0,0 +1,89 @@
+use std::fmt::Debug;
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_merge_sort_unsorted() {
+        // Test case 1: Unsorted integers
+        let arr = vec![3, 2, 5, 1, 4];
+        assert_eq!(merge_sort(arr), vec![1, 2, 3, 4, 5]);
+    }
+
+    #[test]
+    fn test_merge_sort_sorted() {
+        // Test case 2: Already sorted integers
+        let arr = vec![1, 2, 3, 4, 5];
+        assert_eq!(merge_sort(arr), vec![1, 2, 3, 4, 5]);
+    }
+
+    #[test]
+    fn test_merge_sort_descending() {
+        // Test case 3: Sorted in descending order integers
+        let arr = vec![5, 4, 3, 2, 1];
+        assert_eq!(merge_sort(arr), vec![1, 2, 3, 4, 5]);
+    }
+
+    #[test]
+    fn test_merge_sort_empty() {
+        // Test case 4: Empty vector
+        let arr: Vec<i32> = Vec::new();
+        assert_eq!(merge_sort(arr), Vec::<i32>::new());
+    }
+
+    #[test]
+    fn test_merge_sort_single_element() {
+        // Test case 5: Vector with one element
+        let arr = vec![42];
+        assert_eq!(merge_sort(arr), vec![42]);
+    }
+
+    #[test]
+    fn test_merge_sort_repeated_elements() {
+        // Test case 6: Vector with repeated elements
+        let arr = vec![9, 5, 7, 5, 2, 9, 7];
+        assert_eq!(merge_sort(arr), vec![2, 5, 5, 7, 7, 9, 9]);
+    }
+}
+
+
+/// Sorts a mutable slice of elements using the merge sort algorithm.
+///
+/// # Examples
+///
+/// ```
+/// let mut vec = vec![3, 2, 5, 1, 4];
+/// merge_sort(&mut vec);
+/// assert_eq!(vec, vec![1, 2, 3, 4, 5]);
+/// ```
+pub fn merge_sort<T: PartialOrd + Copy + Debug>(arr: Vec<T>) -> Vec<T> {
+    if arr.len() < 2 {
+        return arr;
+    }
+    
+    let len = arr.len();
+    let mid = len / 2;
+    let left: Vec<T> = arr[0..mid].to_vec();
+    // println!("{:?}",left);
+    let right: Vec<T> = arr[mid..].to_vec();
+    // println!("{:?}",right);
+    
+    let sorted_left = merge_sort(left.clone());
+    let sorted_right = merge_sort(right.clone());
+    
+    return stitch(sorted_left,sorted_right);
+}
+
+fn stitch<T: PartialOrd + Copy + Debug>(mut left: Vec<T>, mut right: Vec<T>)-> Vec<T> {
+    let mut result: Vec<T> = Vec::new();
+    while !left.is_empty() && !right.is_empty() {
+        if left[0] <= right[0] {
+            result.push(left.remove(0));
+        } else {
+            result.push(right.remove(0));
+        }
+    }
+    result.extend(left);
+    result.extend(right);
+    return result
+}

src/quick_sort.rs

@@ -10,8 +10,8 @@ mod tests {
     }
 }
 
-fn partition(arr: &mut [usize], low: usize, high: usize) -> usize {
-    let pivot = arr[high];
+fn partition<T: Ord + Clone>(arr: &mut [T], low: usize, high: usize) -> usize {
+    let pivot = arr[high].clone();
     let mut idx = low;
     for i in low..high {
         if arr[i] <= pivot {
@@ -23,7 +23,7 @@ fn partition(arr: &mut [usize], low: usize, high: usize) -> usize {
     idx
 }
 
-fn qs(arr: &mut [usize], low: usize, high: usize) {
+fn qs<T: Ord + Clone>(arr: &mut [T], low: usize, high: usize) {
     if low < high {
         let pivot_idx = partition(arr, low, high);
         if pivot_idx > 0 {
@@ -33,7 +33,7 @@ fn qs(arr: &mut [usize], low: usize, high: usize) {
     }
 }
 
-pub fn quick_sort(arr: &mut [usize]) {
+pub fn quick_sort<T: Ord + Clone>(arr: &mut [T]) {
     let len = arr.len();
     if len > 0 {
         qs(arr, 0, len - 1);

src/radix_sort.rs

@@ -0,0 +1,3 @@
+pub fn radix_sort(){
+    
+}