quick sort rust

Author: wuyinjun.oreki

快速排序/main.rs

@@ -1,45 +1,37 @@
 impl Solution {
-    pub fn sort_array(num: Vec<i32>) -> Vec<i32> {
-        return vec![];
-    }
-
-    fn quick_sort(num: &Vec<i32>) -> &Vec<i32> {
-        if num.len() < 1 {
-            return &vec![];
-        }
-        if num.len() == 1 {
-            return num;
+    fn quick_sort(nums: &mut [i32], left: isize, right: isize) {
+        if left <= right {                               // 1
+            let mid = Solution::partition(nums, left, right);     // 2
+            Solution::quick_sort(nums, left, mid - 1);   // 3
+            Solution::quick_sort(nums, mid + 1, right);   // 4
         }
-        let mid = Solution::partition(&num, 0, num.len() - 1);
-        let left_slice = Solution::quick_sort(num[..mid]);
-        let right_slice = Solution::quick_sort(num[mid+1..]);
-        let temp = [left_slice, vec![num[mid]], right_slice].concat();
-        return temp;
     }
 
-    fn partition(num: &Vec<i32>, left: usize, right: usize) -> usize {
-        let pivot = num[right];
-        let i = left;
-        for j in left .. right {
-            if num[j] > pivot {
-                Solution::swap_here(num, i, j);
-                i += 1;
+    fn partition(arr: &mut [i32], lo: isize, hi: isize) -> isize {
+        // -- Determine the pivot --
+        // In Lomuto parition scheme,
+        // the latest element is always chosen as the pivot.
+        let pivot = arr[hi as usize];               // 1
+        let mut i = lo;
+    
+        // -- Swap elements --
+        for j in lo..hi {                           // 2
+            if arr[j as usize] < pivot {
+                arr.swap(i as usize, j as usize);
+                i += 1;                             // 3
             }
         }
-        Solution::swap_here(num, i, right);
-        return i;
-    }
-
-    fn swap_here(num: &Vec<i32>, x: usize, y: usize) {
-        let temp = num[x];
-        num[x] = num[y];
-        num[y] = temp;
+        // Swap pivot to the middle of two piles.
+        arr.swap(i as usize, hi as usize);          // 4
+        i // Return the final index of the pivot
     }
 }
 struct Solution {
 
 }
 
 fn main() {
-
+    let mut list = [1,5,2,35,6,0,-4,2,123,45,652];
+    Solution::quick_sort(&mut list, 0, 10);
+    println!("{:?}", list);
 }