From d646c600f3b9abf99e38dcce12708de3fd348588 Mon Sep 17 00:00:00 2001
From: specCon18 <steven.carpenter@skdevstudios.com>
Date: Sat, 25 May 2024 01:21:39 -0400
Subject: [PATCH] refactored merge_sort

---
 src/merge_sort.rs | 61 +++++++++++++++++++++++++++++++----------------
 1 file changed, 40 insertions(+), 21 deletions(-)

diff --git a/src/merge_sort.rs b/src/merge_sort.rs
index 42f75e6..1095d6f 100644
--- a/src/merge_sort.rs
+++ b/src/merge_sort.rs
@@ -5,76 +5,95 @@ mod tests {
 
     #[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.
+/// Sorts a given vector 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]);
+/// let unsorted = vec![5, 3, 2, 4, 1];
+/// let sorted = merge_sort(unsorted);
+/// assert_eq!(sorted, 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;
+///
+/// # Arguments
+///
+/// * `vec` - A vector of elements implementing `PartialOrd`, `Copy`, and `Debug`.
+///
+/// # Returns
+///
+/// A new vector containing elements from the input vector, sorted in ascending order.
+pub fn merge_sort<T: PartialOrd + Copy + Debug>(vec: Vec<T>) -> Vec<T> {
+    if vec.len() < 2 {
+        return vec;
     }
     
-    let len = arr.len();
+    let len = vec.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 left: Vec<T> = vec[0..mid].to_vec();
+    let right: Vec<T> = vec[mid..].to_vec();
     
     let sorted_left = merge_sort(left.clone());
     let sorted_right = merge_sort(right.clone());
     
-    return stitch(sorted_left,sorted_right);
+    return stitch(sorted_left, sorted_right);
 }
 
-fn stitch<T: PartialOrd + Copy + Debug>(mut left: Vec<T>, mut right: Vec<T>)-> Vec<T> {
+/// Merges two sorted vectors into a single sorted vector.
+///
+/// # Examples
+///
+/// ```
+/// let left = vec![1, 3, 5];
+/// let right = vec![2, 4, 6];
+/// let merged = stitch(left, right);
+/// assert_eq!(merged, vec![1, 2, 3, 4, 5, 6]);
+/// ```
+///
+/// # Arguments
+///
+/// * `left` - A sorted vector of elements implementing `PartialOrd`, `Copy`, and `Debug`.
+/// * `right` - A sorted vector of elements implementing `PartialOrd`, `Copy`, and `Debug`.
+///
+/// # Returns
+///
+/// A new vector containing elements from both input vectors, sorted in ascending order.
+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] {
@@ -85,5 +104,5 @@ fn stitch<T: PartialOrd + Copy + Debug>(mut left: Vec<T>, mut right: Vec<T>)-> V
     }
     result.extend(left);
     result.extend(right);
-    return result
+    return result;
 }