Refactoring (#11)

* Use boolean to determine if swaps were made

* Refactor to export quicksort directly

* Refactored tests

* Export named functions instead of lambdas

* Updated npm keywords

* Refactored merge function

Author: jasonheecs

package.json

@@ -21,7 +21,13 @@
   },
   "keywords": [
     "sorting",
-    "algorithms"
+    "algorithms",
+    "sort",
+    "bubble sort",
+    "insertion sort",
+    "merge sort",
+    "quicksort",
+    "selection sort"
   ],
   "author": "jasonheecs",
   "license": "MIT",

src/bubble-sort.js

@@ -6,17 +6,17 @@ import {swap} from './helper.js';
  * @param  {Array} elements
  * @return {Array}
  */
-export default (elements) => {
-  let swapCounter = -1;
+export default function bubbleSort (elements) {
+  let done = false;
   let limit = elements.length - 1;
 
-  while (swapCounter !== 0) {
-    swapCounter = 0;
+  while (!done) {
+    done = true;
 
     for (let i = 0; i < limit; i++) {
       if (elements[i] > elements[i + 1]) {
         swap(elements, i, i + 1);
-        swapCounter++;
+        done = false;
       }
     }
 

src/insertion-sort.js

@@ -4,7 +4,7 @@
  * @param  {Array} elements
  * @return {Array}
  */
-export default (elements) => {
+export default function insertionSort (elements) {
   let valueToInsert;
   let index;
 

src/merge-sort.js

@@ -11,13 +11,12 @@ function merge (left, right) {
   let j = 0;
 
   while (i < left.length || j < right.length) {
-    if (i < left.length && j < right.length) {
-      if (left[i] < right[j]) {
-        mergedArr.push(left[i++]);
-      } else {
+    if (i < left.length) {
+      if (j < right.length && right[j] < left[i]) {
         mergedArr.push(right[j++]);
+        continue;
       }
-    } else if (i < left.length) {
+
       mergedArr.push(left[i++]);
     } else {
       mergedArr.push(right[j++]);

src/quicksort.js

@@ -2,23 +2,6 @@
 
 import {swap} from './helper.js';
 
-/**
- * @param  {Array} elements
- * @param  {number} left
- * @param  {number} right
- * @return {Array}
- */
-function quickSort (elements, left, right) {
-  if (left < right) {
-    let partitionIndex = partition(elements, left, right);
-
-    quickSort(elements, left, partitionIndex - 1);
-    quickSort(elements, partitionIndex + 1, right);
-  }
-
-  return elements;
-}
-
 /**
  * @param  {Array} elements
  * @param  {number} left
@@ -42,12 +25,17 @@ function partition (elements, left, right) {
 
 /**
  * @param  {Array} elements
+ * @param  {number} left
+ * @param  {number} right
  * @return {Array}
  */
-export default (elements) => {
-  if (elements.length < 2) {
-    return elements;
+export default function quickSort (elements, left = 0, right = (elements.length - 1)) {
+  if (elements.length > 1 && left < right) {
+    let partitionIndex = partition(elements, left, right);
+
+    quickSort(elements, left, partitionIndex - 1);
+    quickSort(elements, partitionIndex + 1, right);
   }
 
-  return quickSort(elements, 0, elements.length - 1);
+  return elements;
 };

src/selection-sort.js

@@ -25,7 +25,7 @@ function findSmallestElementIndex (elements, startIndex) {
  * @param  {Array} elements
  * @return {Array}
  */
-export default (elements) => {
+export default function selectionSort (elements) {
   elements.forEach((el, index) => {
     let smallestElementIndex = findSmallestElementIndex(elements, index);
 

test/common.js

@@ -8,13 +8,7 @@ const expect = (require('chai')).expect;
  * @return {boolean}
  */
 function arrayIsSorted (arr) {
-  return arr.every((el, index) => {
-    if (index < arr.length - 1) {
-      return (el <= arr[index + 1]);
-    } else {
-      return true;
-    }
-  });
+  return arr.every((el, index) => el <= arr[index + 1] || index >= arr.length - 1);
 }
 
 /**
@@ -83,4 +77,20 @@ export default (algoToTest) => {
   it('with empty array', testFunc([], algoToTest, (testItem) => {
     expect(testItem).to.deep.equal([]);
   }));
+
+  it('with already sorted array', testFunc([1, 2, 3, 4, 5], algoToTest, (testItem) => {
+    expect(arrayIsSorted(testItem)).to.be.true;
+  }));
+
+  it('with sorted array in reverse order', testFunc([5, 4, 3, 2, 1], algoToTest, (testItem) => {
+    expect(arrayIsSorted(testItem)).to.be.true;
+  }));
+
+  it('with negative values', testFunc([-5, 2, -3, 1, 0], algoToTest, (testItem) => {
+    expect(arrayIsSorted(testItem)).to.be.true;
+  }));
+
+  it('with repeated values', testFunc([1, 1, 1, 1, 1], algoToTest, (testItem) => {
+    expect(arrayIsSorted(testItem)).to.be.true;
+  }));
 };