more tests

Author: amejiarosario

book/chapters/timsort.adoc

@@ -0,0 +1,57 @@
+= tim Sort
+
+tim sort is an efficient recursive sorting algorithm that uses "divide and conquer" paradigm to sort faster. It can be implemented in-place so it doesn't require additonal memory.
+
+In practice timsort outperforms efficient sorting algorithms like <<Merge Sort>>. And, of course, It also outperforms simple sorting algorithms like <<Selection Sort>>, <<Insertion Sort>> and <<Bubble Sort>>.
+
+tim sort 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.
+
+== tim Sort Implementation
+
+tim sort implementation uses the divide-and-conquer in the following way:
+
+.tim Sort 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.
+
+Let's convert these words into code!
+
+.tim Sort implementation in JavaScript (timSort)
+[source, javascript]
+----
+include::{codedir}/algorithms/sorting/tim-sort.js[tag=timSort, indent=0]
+----
+<1> Partition: picks a pivot and find the index where the pivot will be when the array is sorted.
+<2> Do the partition of the sub-array at the left of the pivot.
+<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:
+
+.tim Sort implementation in JavaScript (partition)
+[source, javascript]
+----
+include::{codedir}/algorithms/sorting/tim-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.
+
+Merge sort has a _O(n log n)_ running time. For more details about the how to extract the runtime go to <<Linearithmic>>.
+
+== tim Sort Properties
+
+- Time Complexity: [big]#✅# <<Linearithmic>> _O(n log n)_
+- Space Complexity: [big]#⚠️# <<Linear>> _O(n)_
+- <<Stable>>: [big]#✅# Yes
+- <<In-place>>: [big]#✅# Yes
+- <<Adaptive>>: [big]#️️️️️️️⛔️️️️️# No, mostly sorted array takes the same time O(n log n).
+- <<Online>>: [big]#️️️️️️️⛔️️️️️# No, the pivot element can be choose at random.
+- Recursive: Yes
+
+
+// Resources:
+// https://twitter.com/mathias/status/1036626116654637057?lang=en
+// http://cr.openjdk.java.net/~martin/webrevs/openjdk7/timsort/raw_files/new/src/share/classes/java/util/TimSort.java

book/images/quicksort.gif

@@ -0,0 +1,65 @@
+const { swap } = require('./sorting-common');
+
+// tag::partition[]
+/**
+ * Linear-time Partitioning
+ * Chooses a pivot and re-arrage the array that
+ *  everything on the left is <= pivot and
+ *  everything on the right is > pivot
+ *
+ * Runtime: O(n)
+ * @param {*} array
+ * @param {*} low start index
+ * @param {*} high end index
+ * @returns {integer} pivot index
+ */
+function partition(array, low, high) {
+  const pivotInitialIndex = high; // <1>
+  let pivotIndex = low; // <2>
+
+  for (let current = low; current < high; current += 1) { // <3>
+    if (array[current] <= array[pivotInitialIndex]) { // <4>
+      swap(array, current, pivotIndex);
+      pivotIndex += 1;
+    }
+  }
+
+  swap(array, pivotInitialIndex, pivotIndex);
+  return pivotIndex;
+}
+// end::partition[]
+
+
+// tag::quickSort[]
+/**
+ * QuickSort - Efficient in-place recursive sorting algorithm.
+ * Avg. Runtime: O(n log n) | Worst: O(n^2)
+ * @param {*} array
+ * @param {*} low
+ * @param {*} high
+ */
+function quickSort(array, low = 0, high = array.length - 1) {
+  if (low < high) { // <4>
+    const partitionIndex = partition(array, low, high); // <1>
+    quickSort(array, low, partitionIndex - 1); // <2>
+    quickSort(array, partitionIndex + 1, high); // <3>
+  }
+  return array;
+}
+// end::quickSort[]
+
+
+// tag::sort[]
+/**
+ * Quick sort
+ * Runtime: O(n log n)
+ * @param {Array|Set} collection elements to be sorted
+ */
+function quickSortWrapper(collection) {
+  const array = Array.from(collection); // <1>
+  return quickSort(array);
+}
+// end::sort[]
+
+
+module.exports = quickSortWrapper;

lab/timsort.java

@@ -0,0 +1,14 @@
+
+
+Compare content with:
+- []	https://adrianmejia.com/blog/2018/04/28/data-structures-time-complexity-for-beginners-arrays-hashmaps-linked-lists-stacks-queues-tutorial/#Stacks
+- []	https://medium.freecodecamp.org/time-is-complex-but-priceless-f0abd015063c
+- []	https://leetcode.com/explore/learn/
+- []	https://github.com/trekhleb/javascript-algorithms
+- []	https://www.khanacademy.org/computing/computer-science/algorithms
+- []	Compare with: Data Structures and Algorithms.pdf by Lydia Hallie
+- []	Cracking code interviews
+- []	Grokking Algorithms
+- []	CS Distilled
+- []	Create poster like: http://bigocheatsheet.com/, http://bigoref.com/,
+- []	https://introcs.cs.princeton.edu/java/11cheatsheet/