quicksort fixes

Author: amejiarosario

book/chapters/quick-sort.adoc

@@ -1,21 +1,21 @@
 = Quicksort
 (((Sorting, QuickSort)))
 (((QuickSort)))
-Quicksort is an efficient recursive sorting algorithm that uses <<Divide and Conquer, divide and conquer>> paradigm to sort faster. It can be implemented in-place so it doesn't require additonal memory.
+Quicksort is an efficient recursive sorting algorithm that uses <<Divide and Conquer, divide and conquer>> paradigm to sort faster. It can be implemented in-place, so it doesn't require additonal memory.
 
 indexterm:[Divide and Conquer]
-In practice quicksort outperforms efficient sorting algorithms like <<Merge Sort>>. And, of course, It also outperforms simple sorting algorithms like <<Selection Sort>>, <<Insertion Sort>> and <<Bubble Sort>>.
+In practice, quicksort outperforms other sorting algorithms like <<Merge Sort>>. And, of course, It also outperforms simple sorting algorithms like <<Selection Sort>>, <<Insertion Sort>> and <<Bubble Sort>>.
 
-Quicksort basically picks a "pivot" element (preferably random) and move all the elements that are smaller than the pivot to the right and the ones that are bigger to the left. It does this recursively until all the array is sorted.
+Quicksort picks a "pivot" element (preferably random) and move all the parts that are smaller than the pivot to the right and the ones that are bigger to the left. It does this recursively until all the array is sorted.
 
 == Quicksort Implementation
 
 Quicksort implementation uses the divide-and-conquer in the following way:
 
 .Quicksort Algorithm
-. Pick a "pivot" element (at random)
-. Move everything that is lower than the pivot to the left and everything that is bigger than the pivot to the right.
-. Recursively repeat step 1 and 2, the sub-arrays on the left and on the right WITHOUT including the pivot.
+. Pick a "pivot" element (at random).
+. Move everything lower than the pivot to the left and everything more significant than the pivot to the right.
+. Recursively repeat step #1 and #2 in the sub-arrays on the left and on the right WITHOUT including the pivot.
 
 Let's convert these words into code!
 
@@ -29,19 +29,45 @@ include::{codedir}/algorithms/sorting/quick-sort.js[tag=quickSort, indent=0]
 <3> Do the partition of the sub-array at the right of the pivot.
 <4> Only do the partition when there's something to divide.
 
-The real heavy-lifting is don in the partion function. Let's implement that:
+The `partition` function does the real heavy-lifting. 🏋️‍♀️
 
 .Quicksort implementation in JavaScript (partition)
 [source, javascript]
 ----
 include::{codedir}/algorithms/sorting/Quick-sort.js[tag=partition, indent=0]
 ----
-<1> Make the rightmost element as the pivot.
-<2> This is the place holder for the final pivot index. We start in low and as we move all the lower elements to the left we will get the final place where the pivot should be.
-<3> Move one element at a time comparing it to the pivot value.
-<4> If the current element value is less than the pivot, then increment pivot index (pivot should be place after all the lower values). We also swap the value before incrementing because current element that is lower than the pivot to be at its left side.
+<1> Take the leftmost element as the pivot.
+<2> `pivotFinalIndex` is the placeholder for the final position where the pivot will be placed when the array is sorted.
+<3> Check all values other than the pivot to see if any value is smaller than the pivot.
+<4> If the `current` element's value is less than the pivot, then increment `pivotFinalIndex` to make room on the left side.
+<5> We also swap the smaller element to the left side since it's smaller than the pivot.
+<6> Finally, we move the pivot to its final position. Everything to the left is smaller than the pivot and everything to the right is bigger.
 
-Merge sort has a _O(n log n)_ running time. For more details about the how to extract the runtime go to <<Linearithmic>>.
+*What would happen if use Quicksort for an array in reverse order?*
+
+E.g. `[10, 7, 5, 4, 2, 1]`, if we always choose the first element as the pivot, we would have to swap everything to the left of `10`.
+
+So in the first partition we would have `[7, 5, 4, 2, 1, 10]`.
+Then, we take `7` would be the next pivot and we have to swap everything to the left.
+This is the worst-case for this quicksort since it will perform O(n^2^) work.
+If instead of partitioning by the first we do it by the middle element (or even better at random) we would have better peformance. That's why we usually shuffle the array to avoid edge cases.
+
+[source, javascript]
+----
+include::{codedir}/algorithms/sorting/Quick-sort.js[tag=sort, indent=0]
+----
+<1> Convert to array (or clone array). If you want to modify the input directly remove this line.
+<2> Shuffle array to avoid edge cases (desc order arrays)
+
+And you can see the implementation of `shuffle` below:
+
+.Shuffling an array
+[source, javascript]
+----
+include::{codedir}/algorithms/sorting/sorting-common.js[tag=shuffle, indent=0]
+----
+
+With the optimization, Quicksort has a _O(n log n)_ running time. Similar to the merge sort we divide the array into halves each time. For more details about the how to extract the runtime go to <<Linearithmic>>.
 
 == Quicksort Properties
 
@@ -60,3 +86,4 @@ indexterm:[Space Complexity, Linear]
 // https://algs4.cs.princeton.edu/23quicksort/
 // https://twitter.com/mathias/status/1036626116654637057?lang=en
 // https://www.toptal.com/developers/sorting-algorithms/quick-sort
+// https://stackoverflow.com/q/19255999/684957 // Is Quicksort “adaptive” and “online”?

src/algorithms/sorting/quick-sort.js

@@ -1,4 +1,4 @@
-const { swap } = require('./sorting-common');
+const { swap, shuffle } = require('./sorting-common');
 
 // tag::partition[]
 /**
@@ -14,18 +14,18 @@ const { swap } = require('./sorting-common');
  * @returns {integer} pivot index
  */
 function partition(array, low, high) {
-  const pivotInitialIndex = high; // <1>
-  let pivotIndex = low; // <2>
+  const pivotIndex = low; // <1>
+  let pivotFinalIndex = pivotIndex; // <2>
 
-  for (let current = low; current < high; current += 1) { // <3>
-    if (array[current] <= array[pivotInitialIndex]) { // <4>
-      swap(array, current, pivotIndex);
-      pivotIndex += 1;
+  for (let current = pivotIndex + 1; current <= high; current++) {
+    if (array[current] < array[pivotIndex]) { // <3>
+      pivotFinalIndex += 1; // <4>
+      swap(array, current, pivotFinalIndex); // <5>
     }
   }
 
-  swap(array, pivotInitialIndex, pivotIndex);
-  return pivotIndex;
+  swap(array, pivotIndex, pivotFinalIndex); // <6>
+  return pivotFinalIndex;
 }
 // end::partition[]
 
@@ -54,9 +54,11 @@ function quickSort(array, low = 0, high = array.length - 1) {
  * Quick sort
  * Runtime: O(n log n)
  * @param {Array|Set} collection elements to be sorted
+ * @returns {Array} sorted array
  */
 function quickSortWrapper(collection) {
   const array = Array.from(collection); // <1>
+  shuffle(array); // <2>
   return quickSort(array);
 }
 // end::sort[]

src/algorithms/sorting/sorting-common.js

@@ -12,20 +12,23 @@ function swap(array, from, to) {
 }
 // end::swap[]
 
+// tag::shuffle[]
 /**
- * Move an element in an array *from* a postion *to* another.
+ * Shuffle items in an array in-place
  * Runtime: O(n)
- * @param {array} array
- * @param {integer} from index of the element to remove (source)
- * @param {integer} to index where the removed element would be move (destination)
+ * @param {*} array
  */
-function moveElement(array, from, to) {
-  if (from === to + 1) return;
-  const [elementToInsert] = array.splice(from, 1); // delete from position
-  array.splice(to + 1, 0, elementToInsert); // insert element in to the position.
+function shuffle(array) {
+  const { length } = array;
+  for (let index = 0; index < length; index++) {
+    const newIndex = Math.floor(Math.random() * length);
+    swap(array, index, newIndex);
+  }
+  return array;
 }
+// end::shuffle[]
 
 module.exports = {
   swap,
-  moveElement,
+  shuffle,
 };