finished quicksort

Author: johannes67890

src/lib.rs

@@ -4,6 +4,12 @@ mod quciksort;
 pub use bubblesort::bubblesort;
 pub use quciksort::quicksort;
 
+// pub fn generate_random_array(salt: i8, range: i32) -> &[i32]{
+//     let mut arr = [];
+//     &arr
+// }
+
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/quciksort.rs

@@ -1,32 +1,62 @@
-pub fn quicksort<T: Ord>(array: &mut [T]) {
-    let low: isize = 0;
-    let high: isize = (array.len() - 1) as isize;
+
+/// # Quicksort
+/// 
+/// The Quicksort algoritm is a Divide and Conquer algorithm. 
+/// Quicksort selects a `pivot` element, and takes the other elements smaller or equal on one side and bigger on the other side.
+/// 
+/// # Ilustration 
+/// `arr = [ 8, 5, 9, 2, 7 ]` (pivot is the last element, in this case 7).
+/// 
+///                <-- `less or equal`      `bigger than` -->
+/// 
+///                              [ 8, 5, 9, 2, 7 ]
+///                                      |
+///                      / ------------- 7 ----------------\ 
+///                  [ 5, 2 ]                            [ 8, 9 ]
+///                      |                                  |
+///               [ ] -- 2 -- [5]                    [8] -- 9 -- [ ]   
+///                      |                                  |            <---- `Now we join them back together`
+///                      \-----    [ 2, 5, 7, 8, 9 ]   ---- /
+///                                  (Sorted array)
+///          
+pub fn quicksort<T: Ord>(array: &mut [T]) { // Takes mut array of type 'T'.
+    let low: isize = 0; // Index '0' of array
+    let high: isize = (array.len() - 1) as isize; // Highest index of array
 
     sort(array, low, high);
 
-    fn sort<T: Ord>(array: &mut [T], low: isize, high: isize){
-        if low < high {
-            let pi: isize = temp(array, low, high);
+}
 
-            sort(array, low, pi - 1);
-            sort(array, (pi + 1) as isize, high);
-         
-    }
 
-    fn temp<T: Ord>(array: &mut [T], low: isize, high: isize) -> isize {
-        let mut i = low - 1; 
+fn sort<T: Ord>(arr: &mut [T], low: isize, high: isize){
+    if low < high {
+        let pivot_element: isize = temp(arr, low, high); // pivot element (always the element of the highest index, in the whole or sub array)
 
-        for j in 0..high {
-            if &array[j as usize] < &array[high as usize] {
+        sort(arr, low, pivot_element - 1); // Before pi
+        sort(arr, pivot_element + 1, high); // After pi
+    }
+    
+    fn temp<T: Ord>(arr: &mut [T], low: isize, high: isize) -> isize {
+    let pivot = high as usize; // Pivot element
+    let mut i = low - 1; 
+    let mut j = high;
 
+    loop {
+            i += 1;
+            while arr[i as usize] < arr[pivot] {
                 i += 1;
-
-                array.swap(i as usize, j as usize);
-
+            }
+            j -= 1;
+            while j >= 0 && arr[j as usize] > arr[pivot] {
+                j -= 1;
+            }  
+            if i >= j { // If current element is smaller than pivot element.
+                break;
+            } else {
+                arr.swap(i as usize, j as usize);
             }
         }
-       array.swap((i + 1) as usize, high as usize);
-       i + 1
-    }
+        arr.swap(i as usize, pivot as usize);
+        i
     }
 }