fix bubble sort

Author: amejiarosario

book/chapters/algorithms-intro.adoc

@@ -8,7 +8,7 @@ We are going to start with <<Sorting Algorithms>>
 then you are going to learn some techniques for solving problems.
 
 
-.We are going to discuss the following approaches for solving algorithms problems:
+.We are going to discuss the following techniques for solving algorithms problems:
 - <<Greedy Algorithms>>: makes greedy choices using heuristics to find the best solution without looking back.
 - <<Dynamic Programming>>: technique for solving problems with _overlapping subproblems_. It uses _memoization_ to avoid duplicated work.
 - <<Divide and Conquer>>: _divide_ problems into smaller pieces, _conquer_ each subproblem and then _join_ the results.

book/chapters/bubble-sort.adoc

@@ -22,10 +22,11 @@ Let's convert these words into code!
 ----
 include::{codedir}/algorithms/sorting/bubble-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.
+<1> Convert any kind of iterable (array, sets, etc.) into an array or if is already and array it clones it so the input is not modified.
+<2> Goes through all the elements in the array
+<3> *Compares in pairs* (current vs next element) and swap them only if they are out of order. Bubbles up largest
+<4> If no swap was needed that means everything is sorted (this make this sorting adaptive, if everything is sorted it will be _O(n)_)
+<5> If a swap as performed means that the largest element is all the way to the right side and no need compare it anymore, thus `array.length - left`.
 
 Bubble sort has a <<Quadratic>> running time, as you might infer from the nested for-loop.
 

book/chapters/sorting-intro.adoc

@@ -4,10 +4,11 @@ Sorting implementations with the same time complexity might manipulate the data
 
 == Stable
 
-An stable sorting algorithms keeps the relative order of items with the same comparison criteria.
+An ((stable sorting)) algorithms keeps the relative order of items with the same comparison criteria.
 
-This specially useful when you want to sort on multiple phases. Let's say you have the following data:
+This specially useful when you want to sort on multiple phases.
 
+.Let's say you have the following data:
 [source, javascript]
 ----
 const users = [
@@ -18,8 +19,7 @@ const users = [
 ];
 ----
 
-If you sort by `name` you would have
-
+.If you sort by `name` you would have:
 [source, javascript]
 ----
 [
@@ -30,10 +30,9 @@ If you sort by `name` you would have
 ];
 ----
 
-Then, here comes the important part, if you sort by `age` you might two different results.
-
-If the sorting algorithm is *stable*, it should keep the items with the same age ordered by `name`:
+Then, here comes the important part, if you sort by `age` you might get two different results.
 
+.If the sorting algorithm is *stable*, it should keep the items with the same age ordered by `name`:
 [source, javascript]
 ----
 [
@@ -44,8 +43,7 @@ If the sorting algorithm is *stable*, it should keep the items with the same age
 ];
 ----
 
-However, if the sorting is *not stable*, then you will lose the relative order of the items and get something like this:
-
+.However, if the sorting is *not stable*, then you will lose the relative order of the items and get something like this:
 [source, javascript]
 ----
 [
@@ -56,18 +54,18 @@ However, if the sorting is *not stable*, then you will lose the relative order o
 ];
 ----
 
-Both results are correct, however, having a sorting algorithm is better if you want to do multiple sorting passes.
+Both results are correctly sorted by `age`, however, having a stable sorting is better if you want to keep the relative possition of keys with the same value.
 
 == In-place
 
-An in-place sorting algorithm would a space complexity of O(1). In other words, it does not use any other auxiliary memory because it moves the items in the collection itself.
+An ((in-place sorting)) algorithm would a _space complexity_ of O(1). In other words, it does not use any other auxiliary memory because it moves the items in the collection itself.
 This is specially useful for memory constraint enviroments like robotics or embedded systems in appliances.
 
 == Online
 
 It can sort a list as it receives it.
-Online algorithms doesn't have to re-sort the whole collection for every new item added.
+((Online sorting)) algorithms doesn't have to re-sort the whole collection for every new item added.
 
 == Adaptive
 
-It runs faster an already sorted or partially sorted collection.
+Algorithms with ((adaptive sorting)) run faster, close to _O(n)_, on an already sorted (or partially sorted) collection.

src/algorithms/sorting/bubble-sort.js

@@ -9,17 +9,20 @@ const { swap } = require('./sorting-common');
 function bubbleSort(collection) {
   const array = Array.from(collection); // <1>
 
+  let swapped = false;
+
   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);
+    for (let right = 0; right < array.length - left; right++) { // <5>
+      if (array[right] > array[right + 1]) { // <3>
+        swap(array, right, right + 1);
+        swapped = true;
       }
     }
+    if (!swapped) break; // <4>
   }
 
   return array;
 }
 // end::sort[]
 
-
 module.exports = bubbleSort;

src/algorithms/sorting/sorting.spec.js

@@ -1,3 +1,4 @@
+/*eslint-disable */
 const sortingAlgorithms = [
   require('./selection-sort'),
   require('./insertion-sort'),
@@ -39,9 +40,5 @@ sortingAlgorithms.forEach((sort) => {
     it('should sort with duplicated values', () => {
       expect(sort([1, 3, 2, 1])).toEqual([1, 1, 2, 3]);
     });
-
-    it('should sort longer arrays', () => {
-
-    });
   });
 });