From 28f33e93e68534d6a7f1a471a2d7369fcb65343d Mon Sep 17 00:00:00 2001
From: Joseph Ferano <joseph@ferano.io>
Date: Mon, 16 Jan 2023 21:06:37 +0700
Subject: [PATCH] Added Skiena's version of random pivot quicksort for
 reference

---
 TheAlgorithmDesignManual.org | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/TheAlgorithmDesignManual.org b/TheAlgorithmDesignManual.org
index 6e208ca..3c1fcc4 100644
--- a/TheAlgorithmDesignManual.org
+++ b/TheAlgorithmDesignManual.org
@@ -649,12 +649,27 @@ void swap(int *i, int *j) {
     ,*j = temp;
 }
 
+void skiena_quicksort(int A[], int p, int q) {
+    if(p >= q) return;
+
+    swap(&A[p + (rand() % (q - p + 1))], &A[q]);   // PIVOT = A[q]
+    int i = p - 1;
+    for(int j = p; j <= q; j++) {
+        if(A[j] <= A[q]) {
+            swap(&A[++i], &A[j]);
+        }
+    }
+
+    skiena_quicksort(A, p, i - 1);
+    skiena_quicksort(A, i + 1, q);
+}
+
 void quicksort(int *array, int start, int end) {
     int len = end - start + 1;
     if (len <= 1) {
         return;
     }
-    int r = (int)((float)rand() / RAND_MAX * len);
+    int r = rand() % len;
     int pivot = array[start + r];
     int mid = start;
     int s = mid;
@@ -666,19 +681,24 @@ void quicksort(int *array, int start, int end) {
             swap(&array[mid], &array[h--]);
         } else {
             mid++;
+            quicksort(array, start, s-1);
+            quicksort(array, s+1, end);
+            return;
         }
     }
     quicksort(array, start, s-1);
     quicksort(array, s+1, end);
-    return;
 }
 
 #define LEN 10
+/* int array[LEN] = {5,4,3,2,1}; */
 int array[LEN] = {5,4,3,2,3,2,1,1,8,6};
+
 for (int i = 0; i < LEN; i++) {
     printf("%i", array[i]);
 } printf("\n");
 
+/* skiena_quicksort(array, 0, LEN - 1); */
 quicksort(array, 0, LEN - 1);
 
 for (int i = 0; i < LEN; i++) {
@@ -686,7 +706,6 @@ for (int i = 0; i < LEN; i++) {
 }
 #+end_src
 
-
 Usually in higher level languages like Python and Haskell, you would allocate
 new arrays to hold the new sorted elements. However, it becomes more challenging
 when doing it in place. This algorithm requires 3 pointers to keep track of the