insertion sort wip

Author: amejiarosario

book/book.adoc

@@ -87,10 +87,10 @@ include::chapters/sorting-intro.adoc[]
 
 // Slow Sorting
 
-include::chapters/selection-sort.adoc[]
-
 include::chapters/insertion-sort.adoc[]
 
+include::chapters/selection-sort.adoc[]
+
 include::chapters/bubble-sort.adoc[]
 
 // Fast Sorting

book/chapters/insertion-sort.adoc

@@ -1,3 +1,12 @@
 = Insertion Sort
 
-Culpa consectetur commodo aute laborum occaecat veniam ea anim consequat esse occaecat nulla incididunt ullamco. Nulla nisi enim eu pariatur veniam cupidatat ullamco laborum. Exercitation velit quis do mollit.
+Insertion sort is one of the most natural way of sorting. If you are given some cards that's probably how you are going to sort the.
+
+.This is how it works:
+
+. Take the first element and consider it sorted.
+. Take the 2nd element, compare it with the first element. It 2nd is smaller swap it with the first element.
+. Go to the 3rd element compare it with the already sorted elements and if any of them is smaller, swap them.
+. Repeat for the rest of the array.
+
+More efficient in practice than most other simple quadratic (i.e., O(n^2^)) algorithms such as <<Selection Sort>> or <<Bubble Sort>>.

book/chapters/selection-sort.adoc

@@ -9,7 +9,7 @@ TIP: selection sort is a in-place sorting algorithms, it should be used when aux
 . Find minimum element in the rest of array. If a new minimun is found swap them.
 . Repeat with the element in postion 1 and so until the last one.
 
-image:https://camo.githubusercontent.com/adfa2cdcc3825092dc405aadd87453571d6e0dc4/68747470733a2f2f75706c6f61642e77696b696d656469612e6f72672f77696b6970656469612f636f6d6d6f6e732f392f39342f53656c656374696f6e2d536f72742d416e696d6174696f6e2e676966[]
+image:selection-sort.gif[]
 
 == Selection sort implementation
 For implementing the selection sort we need 2 indexes.

book/chapters/sorting-intro.adoc

@@ -5,3 +5,9 @@ Excepteur ad occaecat ex dolor reprehenderit esse occaecat exercitation Lorem. C
 
 - In-place vs auxiliary memory usage
 - Stable vs inestable
+
+
+- Stable: does not change the relative order of elements with equal keys.
+- In-place: only requires a constant amount O(1) of additional memory space. Does not use any other auxiliary memory.
+- Online: can sort a list as it receives it.
+- Adaptive: efficient for data sets that are already substantially sorted.

book/images/selection-sort.gif

@@ -0,0 +1,20 @@
+const { swap } = require('./sorting-common');
+
+function insertionSort(collection) {
+  const array = Array.from(collection);
+
+  for (let outer = 1; outer < array.length; outer += 1) {
+    const insert = array[outer];
+
+    for (let inner = outer - 1; inner >= 0; inner -= 1) {
+      const element = array[inner];
+
+      if (insert < element) {
+        swap(array, inner, outer);
+      }
+    }
+  }
+  return array;
+}
+
+module.exports = insertionSort;

src/algorithms/sorting/insertion-sort.js

@@ -1,14 +1,4 @@
-// tag::swap[]
-/**
- * Swap array elements in place
- * @param {array} array to be modified
- * @param {integer} from index of the first element
- * @param {integer} to index of the 2nd element
- */
-function swap(array, from, to) {
-  [array[from], array[to]] = [array[to], array[from]];
-}
-// end::swap[]
+const { swap } = require('./sorting-common');
 
 // tag::sort[]
 /**

src/algorithms/selection-sort.js renamed to src/algorithms/sorting/selection-sort.js

@@ -0,0 +1,15 @@
+// tag::swap[]
+/**
+ * Swap array elements in place
+ * @param {array} array to be modified
+ * @param {integer} from index of the first element
+ * @param {integer} to index of the 2nd element
+ */
+function swap(array, from, to) {
+  [array[from], array[to]] = [array[to], array[from]];
+}
+// end::swap[]
+
+module.exports = {
+  swap,
+};