Add countingSort.sortWithMinMax(array, min, max) called through sort,…

… added tests. Minor optimisation to counting sort. Bumped minor version number.

bower.json

@@ -1,6 +1,6 @@
 {
   "name": "js-sorting",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "homepage": "https://github.com/Tyriar/js-sorting",
   "authors": [
     "Daniel Imms (http://www.growingwiththeweb.com)"

package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-sorting",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "A collection of sorting algorithms written in JavaScript.",
   "devDependencies": {
     "jasmine-node": "~1.14.3"

src/counting-sort.js

@@ -25,24 +25,65 @@
     sort: sort
   };
 
-  // maxValue is optional, specifying it will initalise the array to the correct
-  // size
-  function sort(array, maxValue) {
+  // Routes function calls to the correct internal method, call like:
+  // sort(array, maxValue)
+  // sort(array, minValue, maxValue)
+  function sort() {
+    if (arguments.length === 2) {
+      return sortWithMax.apply(null, arguments);
+    }
+    if (arguments.length === 3) {
+      return sortWithMinAndMax.apply(null, arguments);
+    }
+    throw "Cannot sort with counting sort with " + arguments.length +
+      " arguments";
+  }
+
+  function sortWithMax(array, maxValue) {
     var buckets = new Array(maxValue + 1);
     var sortedIndex = 0;
     var i;
 
+    for (i = 0; i < array.length; i++) {
+      if (!buckets[array[i]]) {
+        buckets[array[i]] = 0;
+      }
+      buckets[array[i]]++;
+    }
+
     for (i = 0; i < buckets.length; i++) {
-      buckets[i] = 0;
+      while (buckets[i] > 0) {
+        array[sortedIndex++] = i;
+        buckets[i]--;
+      }
+    }
+
+    return array;
+  }
+
+  function sortWithMinAndMax(array, minValue, maxValue) {
+    if (array.length === 0) {
+      return array;
     }
 
+    var rangeSize = maxValue - minValue;
+    var buckets = new Array(rangeSize);
+    var sortedIndex = 0;
+    var i;
+
     for (i = 0; i < array.length; i++) {
-      buckets[array[i]]++;
+      // Change the value to a zero-based index
+      var bucketIndex = array[i] - minValue;
+      if (!buckets[bucketIndex]) {
+        buckets[bucketIndex] = 0;
+      }
+      buckets[bucketIndex]++;
     }
 
     for (i = 0; i < buckets.length; i++) {
       while (buckets[i] > 0) {
-        array[sortedIndex++] = i;
+        // Change the index to the correct value
+        array[sortedIndex++] = i + minValue;
         buckets[i]--;
       }
     }

test/counting-sort-spec.js

@@ -20,3 +20,19 @@ describe("counting-sort", function () {
   }
 });
 
+// Test sort(array, minValue, maxValue) for arrays with a specific range.
+describe("counting-sort", function () {
+  for (var i = 0; i < testHelper.tests.length; i++) {
+    (function (test) {
+      var sorted = testHelper.getSorted(test);
+      var original = testHelper.getOriginal(test);
+      var minValue = sorted[0];
+      var maxValue = sorted[sorted.length - 1];
+
+      it(test.it, function () {
+        expect(algorithm.sort(original, minValue, maxValue))
+          .toEqual(sorted);
+      });
+    })(testHelper.tests[i]);
+  }
+});