Added Shaker Sort Algorithm

src/sorting/readme.md

@@ -1,21 +1,22 @@
 # Comparison of all sorting algorithms
 
-| Algorithm                  | Complexity                                          | When to use? |
-|----------------------------|-----------------------------------------------------|--------------|
-| 3-way-string-quicksort.js  | O(N^2)                                              |              |
-| bubblesort.js              | O(N^2)                                              |              |
-| bucketsort.js              | O(N)                                                |              |
-| countingsort.js            | O(N)                                                |              |
-| heapsort.js                | O(N log N)                                          |              |
-| insertion-binary-sort.js   | O(N^2)                                              |              |
-| insertionsort.js           | O(N^2)                                              |              |
-| lsd.js                     | O(N*M) for N keys which have M or fewer digits      |              |
-| mergesort.js               | O(n log(n))                                         |              |
-| msd.js                     | O(N*M) for N keys which have M or fewer digits      |              |
-| oddeven-sort.js            | O(N^2)                                              |              |
-| quicksort-middle.js        | O(N log(N))                                         |              |
-| quicksort.js               | O(nlog n)                                           |              |
-| radixsort.js               | O(N K) for N keys with K being                      |              |
-| recursive-insertionsort.js | O(N^2)                                              |              |
-| selectionsort.js           | O(N^2)                                              |              |
-| shellsort.js               | O((nlog(n))^2)                                      |              |
+| Algorithm                  | Complexity                                      | When to use? |
+| -------------------------- | ----------------------------------------------- | ------------ |
+| 3-way-string-quicksort.js  | O(N^2)                                          |              |
+| bubblesort.js              | O(N^2)                                          |              |
+| bucketsort.js              | O(N)                                            |              |
+| countingsort.js            | O(N)                                            |              |
+| heapsort.js                | O(N log N)                                      |              |
+| insertion-binary-sort.js   | O(N^2)                                          |              |
+| insertionsort.js           | O(N^2)                                          |              |
+| lsd.js                     | O(N\*M) for N keys which have M or fewer digits |              |
+| mergesort.js               | O(n log(n))                                     |              |
+| msd.js                     | O(N\*M) for N keys which have M or fewer digits |              |
+| oddeven-sort.js            | O(N^2)                                          |              |
+| quicksort-middle.js        | O(N log(N))                                     |              |
+| quicksort.js               | O(nlog n)                                       |              |
+| radixsort.js               | O(N K) for N keys with K being                  |              |
+| recursive-insertionsort.js | O(N^2)                                          |              |
+| selectionsort.js           | O(N^2)                                          |              |
+| shellsort.js               | O((nlog(n))^2)                                  |              |
+| shakersort.js              | O(N^2)                                          |              |

src/sorting/shakersort.js

@@ -0,0 +1,60 @@
+(function (exports) {
+  'use strict';
+
+  function comparator(a, b) {
+    return a - b;
+  }
+
+  /**
+   * Shaker sort algorithm.<br><br>
+   * Complexity: O(N^2).
+   *
+   * @example
+   * var sort = require('path-to-algorithms/src/' +
+   * 'sorting/shakersort').shakerSort;
+   * console.log(sort([2, 5, 1, 0, 4])); // [ 0, 1, 2, 4, 5 ]
+   *
+   * @public
+   * @module sorting/shakersort
+   * @param {Array} array Input array.
+   * @param {Function} cmp Optional. A function that defines an
+   * alternative sort order. The function should return a negative,
+   * zero, or positive value, depending on the arguments.
+   * @return {Array} Sorted array.
+   */
+  function shakerSort(array, cmp) {
+    cmp = cmp || comparator;
+    var temp;
+    var swapped = true;
+    while (swapped){
+      swapped = false;
+      for (var i = 0; i < array.length - 1 ; i += 1) {
+        if (cmp(array[i], array[i + 1]) > 0){
+          temp = array[i];
+          array[i] = array[i + 1];
+          array[i + 1] = temp;
+          swapped = true;
+        }
+      }
+      if (!swapped){
+        break;
+      }
+      swapped = false;
+      for (var i = array.length - 1; i > 0 ; i -= 1) {
+        if (cmp(array[i], array[i - 1]) < 0){
+          temp = array[i];
+          array[i] = array[i - 1];
+          array[i - 1] = temp;
+          swapped = true;
+        }
+      }
+      if (!swapped){
+        break;
+      }
+    }
+    return array;
+  }
+
+  exports.shakerSort = shakerSort;
+
+})(typeof window === 'undefined' ? module.exports : window);

test/sorting/shakersort.spec.js

@@ -0,0 +1,5 @@
+var sortTestCase = require('./sort.testcase.js');
+var shakerSort =
+      require('../../src/sorting/shakersort.js').shakerSort;
+
+sortTestCase(shakerSort, 'Shaker sort');