fix sorting algorithms

Author: amejiarosario

book/chapters/chapter4.adoc

@@ -23,11 +23,14 @@ include::sorting-intro.adoc[]
 
 // Slow Sorting
 
-include::insertion-sort.adoc[]
+include::bubble-sort.adoc[]
 
 include::selection-sort.adoc[]
 
-include::bubble-sort.adoc[]
+include::insertion-sort.adoc[]
+
+
+// include::insertion-selection-bubble-sort.adoc[]
 
 // Fast Sorting
 

book/chapters/insertion-sort.adoc

@@ -6,11 +6,6 @@ If you are given some cards that's probably how you are going to sort them.
 
 // Good illustration on of sorting a deck of cards:  https://www.khanacademy.org/computing/computer-science/algorithms/insertion-sort/a/insertion-sort
 
-.This is how it works:
-. Visit 2nd. If the current element is smaller than the previous one move to the place it should be.
-. Visit next element and do the same thing. The left is always sorted and the right is not (yet).
-. Repeat for the rest of the array.
-
 == Insertion Sort Implementation
 
 .Insertion sort
@@ -19,11 +14,16 @@ If you are given some cards that's probably how you are going to sort them.
 include::{codedir}/algorithms/sorting/insertion-sort.js[tag=sort, indent=0]
 ----
 
-//.Swap function
-//[source, javascript]
-//----
-//include::{codedir}/algorithms/insertion-sort.js[tag=swap, indent=0]
-//----
+// .Swap function
+// [source, javascript]
+// ----
+// include::{codedir}/algorithms/insertion-sort.js[tag=swap, indent=0]
+// ----
+
+.This is how it works:
+. Visit 2nd. If the current element is smaller than the previous one move to the place it should be.
+. Visit next element and do the same thing. The left side is always sorted and the right is not (yet).
+. Repeat for the rest of the array.
 
 == Insertion Sort Properties
 

book/chapters/merge-sort.adoc

@@ -52,10 +52,10 @@ Merge sort has a _O(n log n)_  running time. For more details about the how to e
 
 == Merge 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).
+- <<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
+- Time Complexity: [big]#✅# <<Linearithmic>> _O(n log n)_
+- Space Complexity: [big]#⚠️# <<Linear>> _O(n)_

book/chapters/quick-sort.adoc

@@ -43,13 +43,13 @@ Merge sort has a _O(n log n)_ running time. For more details about the how to ex
 
 == Quicksort 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.
+- <<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
+- Time Complexity: [big]#✅# <<Linearithmic>> _O(n log n)_
+- Space Complexity: [big]#⚠️# <<Linear>> _O(n)_
 
 
 // Resources:

book/chapters/selection-sort.adoc

@@ -63,7 +63,8 @@ Without destructuring assignment, swapping two values requires a temporary varia
 
 == Selection Sort Properties
 
-- <<Stable>>: [big]#✅# Yes
+// - <<Stable>>: [big]#✅# Yes
+- <<Stable>>: [big]#️️❌# No
 - <<In-place>>: [big]#✅# Yes
 - <<Online>>: [big]#✅# Yes
 - <<Adaptive>>: [big]#✅# Yes

src/algorithms/sorting/bubble-sort.js

@@ -2,17 +2,17 @@ const { swap } = require('./sorting-common');
 
 // tag::sort[]
 /**
- * Bubble sort
+ * Bubble sort - Bubbles up bigger values to the right side
  * Runtime: O(n^2)
  * @param {Array|Set} collection elements to be sorted
  */
 function bubbleSort(collection) {
   const array = Array.from(collection); // <1>
 
-  for (let outer = 0; outer < array.length; outer += 1) { // <2>
-    for (let inner = outer + 1; inner < array.length; inner += 1) { // <3>
-      if (array[outer] > array[inner]) { // <4>
-        swap(array, outer, inner);
+  for (let left = 0; left < array.length; left++) { // <2>
+    for (let right = left + 1; right < array.length; right++) { // <3>
+      if (array[left] > array[right]) { // <4>
+        swap(array, left, right);
       }
     }
   }

src/algorithms/sorting/insertion-sort.js

@@ -2,20 +2,24 @@ const { swap } = require('./sorting-common');
 
 // tag::sort[]
 /**
- * Sorting by insertion - start from the 2nd element,
- * it tries to find any element (to the left) that could be bigger than the current index.
+ * Sorting by insertion - Look for bigger numbers on the left side
+ *
+ * It starts from the 2nd element,
+ * and it tries to find any element (to the left)
+ * that could be bigger than the current index.
  * It will move all the elements that are bigger and insert the current element where it belongs.
+ *
  * Runtime: O(n^2)
  * @param {Array|Set} collection elements to be sorted
  */
 function insertionSort(collection) {
   const array = Array.from(collection);
 
-  for (let outer = 1; outer < array.length; outer++) {
-    const insert = array[outer];
+  for (let right = 1; right < array.length; right++) {
+    const insert = array[right];
 
-    for (let inner = outer - 1; array[inner] > insert; inner--) {
-      swap(array, inner + 1, inner);
+    for (let left = right - 1; array[left] > insert; left--) {
+      swap(array, left + 1, left);
     }
   }
   return array;

src/algorithms/sorting/selection-sort.js

@@ -2,24 +2,28 @@ const { swap } = require('./sorting-common');
 
 // tag::sort[]
 /**
- * Selection sort - start from the first element,
- * it tries to find any element (to the right) that could be smaller than the current index.
+ * Selection sort - Look for smaller numbers on the right side
+ *
+ * It starts from the first element (index 0),
+ * and tries to find any element (to the right)
+ * that could be smaller than the current index.
  * If it finds one, it will swap the positions.
+ *
  * Runtime: O(n^2)
  * @param {Array|Set} collection elements to be sorted
  */
 function selectionSort(collection) {
   const array = Array.from(collection);
 
-  for (let outer = 0; outer < array.length; outer += 1) {
-    let selection = array[outer];
+  for (let left = 0; left < array.length; left++) {
+    let selection = array[left];
 
-    for (let inner = outer + 1; inner < array.length; inner += 1) {
-      const element = array[inner];
+    for (let right = left + 1; right < array.length; right++) {
+      const element = array[right];
 
       if (element < selection) {
-        swap(array, outer, inner);
-        selection = array[outer];
+        swap(array, left, right);
+        selection = array[left];
       }
     }
   }