feat: improve gnome_sort

src/sorting/gnome_sort.rs

@@ -1,27 +1,18 @@
-use std::cmp;
-
-pub fn gnome_sort<T>(arr: &[T]) -> Vec<T>
+std::cmp
+pub fn gnome_sort<T>(arr: &mut [T])
 where
- T: cmp::PartialEq + cmp::PartialOrd + Clone,
+ T: cmp::PartialOrd,
 {
- let mut arr = arr.to_vec();
- let mut i: usize = 1;
- let mut j: usize = 2;
+ let mut i = 1;
 
  while i < arr.len() {
- if arr[i - 1] < arr[i] {
- i = j;
- j = i + 1;
+ if i == 0 || arr[i - 1] <= arr[i] {
+ i += 1;
  } else {
  arr.swap(i - 1, i);
  i -= 1;
- if i == 0 {
- i = j;
- j += 1;
- }
  }
  }
- arr
 }
 
 #[cfg(test)]
@@ -32,19 +23,22 @@
 
  #[test]
  fn odd_number_of_elements() {
- let res = gnome_sort(&vec!["d", "a", "c", "e", "b"]);
- assert_eq!(res, vec!["a", "b", "c", "d", "e"]);
+ let mut arr = vec!["d", "a", "c", "e", "b"];
+ gnome_sort(&mut arr);
+ assert_eq!(arr, vec!["a", "b", "c", "d", "e"]);
  }
 
  #[test]
  fn one_element() {
- let res = gnome_sort(&vec![3]);
- assert_eq!(res, vec![3]);
+ let mut arr = vec![3];
+ gnome_sort(&mut arr);
+ assert_eq!(arr, vec![3]);
  }
 
  #[test]
  fn empty() {
- let res = gnome_sort(&Vec::<u8>::new());
- assert_eq!(res, vec![]);
+ let mut arr: Vec<u8> = Vec::new();
+ gnome_sort(&mut arr);
+ assert_eq!(arr, vec![]);
  }
 }

src/sorting/merge_sort.rs

@@ -7,32 +7,32 @@ pub fn merge_sort<T: Ord + Copy>(array: &[T]) -> Vec<T> {
  if array.len() < 2 {
  return array.to_vec();
  }
- // Get the middle element of the array.
  let middle = array.len() / 2;
- // Divide the array into left and right halves.
- let mut left = merge_sort(&array[..middle]);
- let mut right = merge_sort(&array[middle..]);
- // Call merge function using parameters as both left array and right array.
- merge(&mut left, &mut right)
+ let left = merge_sort(&array[..middle]);
+ let right = merge_sort(&array[middle..]);
+ merge(&left, &right)
 }
 
-fn merge<T: Ord + Copy>(left: &mut Vec<T>, right: &mut Vec<T>) -> Vec<T> {
- let mut result = Vec::new();
-
- for _ in 0..left.len() + right.len() {
- if left.is_empty() {
-  result.append(right);
-  break;
- } else if right.is_empty() {
-  result.append(left);
-  break;
- } else if left[0] <= right[0] {
- result.push(left.remove(0));
+fn merge<T: Ord + Copy>(left: &[T], right: &[T]) -> Vec<T> {
+ let mut result = Vec::with_capacity(left.len() + right.len());
+ let mut left_iter = left.iter();
+ let mut right_iter = right.iter();
+
+ let mut left_next = left_iter.next();
+ let mut right_next = right_iter.next();
+
+ while let (Some(left_val), Some(right_val)) = (left_next, right_next) {
+ if left_val <= right_val {
+  result.push(*left_val);
+ left_next = left_iter.next();
  } else {
- result.push(right.remove(0));
+ result.push(*right_val);
+ right_next = right_iter.next();
  }
  }
 
+ result.extend(left_next);
+ result.extend(right_next);
  result
 }