merge sort doc

Author: amejiarosario

book/chapters/merge-sort.adoc

@@ -17,23 +17,32 @@ Merge sort implementation is as follows
 
 Let's convert these words into code!
 
-.Merge Sort implementation in JavaScript
+.Merge Sort implementation in JavaScript (mergeSort)
 [source, javascript]
 ----
 include::{codedir}/algorithms/sorting/merge-sort.js[tag=sort, indent=0]
 ----
 <1> Convert any kind of iterable (array, sets, etc.) into an array
-<2> Start on the first element (position 0)
-<3> Start scanning elements that are to the right of the current element.
-<4> If the previous element is bigger than the previous one, then swap them. This is called bubbling up bigger values to the right.
+
+As you can see this function is just a wrapper to transform things to array. The heavy lifting is done in `splitSort` as you can see below.
+
+.Merge Sort implementation in JavaScript (splitSort)
+[source, javascript]
+----
+include::{codedir}/algorithms/sorting/merge-sort.js[tag=splitSort, indent=0]
+----
+<1> Recursively divide the array in half until two or less elements are left.
+<2> Sort two or less elements.
+<3> Merge back the sorted halves in ascending order.
 
 Merge sort has a <<Quadratic>> running time, as you might infer from the nested for-loop.
 
 == Merge Sort Properties
 
+- Time Complexity: [big]#✅# <<Linearithmic>> _O(n log n)_
+- Space Complexity: [big]#⚠️# <<Linear>> _O(n)_
 - <<Stable>>: [big]#✅# Yes
-- <<In-place>>: [big]#✅# Yes
-- <<Online>>: [big]#✅# Yes
-- <<Adaptive>>: [big]#✅# Yes
-- Time Complexity: [big]#⛔️# <<Quadratic>> _O(n^2^)_
-- Space Complexity: [big]#✅# <<Constant>> _O(1)_
+- <<In-place>>: [big]#⛔️️️️️# No, it requires auxiliary memory O(n).
+- <<Online>>: [big]#️️️️️️️⛔️️️️️# No, new elements will require to sort the whole array.
+- <<Adaptive>>: [big]#️️️️️️️⛔️️️️️# No, mostly sorted array takes the same time O(n log n).
+- Recursive: Yes

book/chapters/quick-sort.adoc

@@ -1,3 +1,48 @@
 = Quick Sort
 
-Veniam veniam et reprehenderit cupidatat laboris incididunt dolore. Mollit id aliqua laboris eiusmod nostrud aliquip enim cillum ipsum consequat tempor. Proident voluptate duis nisi elit aliqua pariatur quis mollit ullamco aliqua qui.
+Quick sort is an efficient sorting algorithm that uses "divide and conquer" paradigm to accomplish it task faster. It uses auxiliary memory in the process of sorting.
+
+== Quick Sort Implementation
+
+Quick sort implementation is as follows
+
+.Quick Sort Algorithm
+. It moves one element at a time (from left to right). Everything on the left of the current element is already sorted, while everything to the right is not.
+. Start with the first element and make it the current element.
+. Compare elements to right of the current element.
+. Quick up big values to the right of the array.
+.. Swap elements if the previous element is bigger than the previous one.
+. Move the current pointer to the next element and repeat for the rest of the array
+
+
+Let's convert these words into code!
+
+.Quick Sort implementation in JavaScript (QuickSort)
+[source, javascript]
+----
+include::{codedir}/algorithms/sorting/Quick-sort.js[tag=sort, indent=0]
+----
+<1> Convert any kind of iterable (array, sets, etc.) into an array
+
+As you can see this function is just a wrapper to transform things to array. The heavy lifting is done in `splitSort` as you can see below.
+
+.Quick Sort implementation in JavaScript (splitSort)
+[source, javascript]
+----
+include::{codedir}/algorithms/sorting/Quick-sort.js[tag=splitSort, indent=0]
+----
+<1> Recursively divide the array in half until two or less elements are left.
+<2> Sort two or less elements.
+<3> Quick back the sorted halves in ascending order.
+
+Quick sort has a <<Quadratic>> running time, as you might infer from the nested for-loop.
+
+== Quick Sort Properties
+
+- Time Complexity: [big]#✅# <<Linearithmic>> _O(n log n)_
+- Space Complexity: [big]#⚠️# <<Linear>> _O(n)_
+- <<Stable>>: [big]#✅# Yes
+- <<In-place>>: [big]#⛔️️️️️# No, it requires auxiliary memory O(n).
+- <<Online>>: [big]#️️️️️️️⛔️️️️️# No, new elements will require to sort the whole array.
+- <<Adaptive>>: [big]#️️️️️️️⛔️️️️️# No, mostly sorted array takes the same time O(n log n).
+- Recursive: Yes

src/algorithms/sorting/merge-sort.js

@@ -24,24 +24,24 @@ function merge(array1, array2 = []) {
 
 // tag::splitSort[]
 /**
- * Split array in half until two or less elements are left.
+ * Split array in half recursively until two or less elements are left.
  * Sort these two elements and combine them back using the merge function.
  * @param {Array} array
  */
 function splitSort(array) {
   const size = array.length;
-
+  // base case
   if (size < 2) {
     return array;
   } else if (size === 2) {
-    return array[0] < array[1] ? array : [array[1], array[0]];
+    return array[0] < array[1] ? array : [array[1], array[0]]; // <2>
   }
 
-  const middle = Math.ceil(size / 2);
-
-  return merge(
-    splitSort(array.slice(0, middle)),
-    splitSort(array.slice(middle)),
+  // recursive split in half and merge back
+  const half = Math.ceil(size / 2);
+  return merge( // <3>
+    splitSort(array.slice(0, half)), // <1>
+    splitSort(array.slice(half)), // <1>
   );
 }
 // end::splitSort[]