Sorting and Searching Algorithms

Author: loiane

.vscode/launch.json

@@ -41,8 +41,9 @@
           "-r",
           "ts-node/register",
           "--colors",
-          "${workspaceRoot}/test/ts/**/*.spec.ts"
+          "${workspaceRoot}/test/ts/**/**/*.spec.ts"
         ],
+        "protocol": "auto",
         "internalConsoleOptions": "openOnSessionStart"
       }
     ]

README.md

@@ -21,6 +21,7 @@ Work in Progress.
 * 09: [Trees](https://github.com/loiane/javascript-datastructures-algorithms/tree/third-edition/examples/chapter09)
 * 10: [Heap](https://github.com/loiane/javascript-datastructures-algorithms/tree/third-edition/examples/chapter10)
 * 11: [Graphs](https://github.com/loiane/javascript-datastructures-algorithms/tree/third-edition/examples/chapter11)
+* 12: [Sorting and Searching Algorithms](https://github.com/loiane/javascript-datastructures-algorithms/tree/third-edition/examples/chapter12)
 
 ### Third Edition Updates
 

package.json

@@ -21,8 +21,8 @@
     "lint:js": "eslint src/js && eslint test/js",
     "lint:ts": "tslint -c tslint.json 'src/ts/**/*.ts' && tslint -c tslint.json 'test/ts/**/*.ts'",
     "lint": "npm run lint:js && npm run lint:ts",
-    "test:js": "mocha --compilers js:babel-core/register ./test/js/**/*.spec.js --reporter mochawesome",
-    "test:ts": "mocha -r ts-node/register --recursive ./test/ts/**/*.spec.ts",
+    "test:js": "mocha --compilers js:babel-core/register ./test/js/**/**/*.spec.js --reporter mochawesome",
+    "test:ts": "mocha -r ts-node/register --recursive ./test/ts/**/**/*.spec.ts",
     "test": "npm run test:js && npm run test:ts",
     "dev": "npm run clean && npm run lint && npm run webpack && npm run generate-report",
     "dev2": "npm run clean && npm run lint && npm run webpack && npm run generate-report2",
@@ -53,28 +53,28 @@
     "all": true
   },
   "devDependencies": {
-    "@types/chai": "^4.0.4",
-    "@types/mocha": "^2.2.44",
+    "@types/chai": "^4.0.10",
+    "@types/mocha": "^2.2.45",
     "babel-cli": "^6.26.0",
     "babel-core": "^6.26.0",
-    "babel-eslint": "^8.0.1",
+    "babel-eslint": "^8.1.0",
     "babel-loader": "^7.1.2",
     "babel-plugin-add-module-exports": "^0.2.1",
     "babel-plugin-transform-es2015-modules-umd": "^6.24.1",
     "babel-preset-env": "^1.6.1",
     "chai": "^4.1.2",
     "codecov": "^3.0.0",
-    "eslint": "^4.10.0",
+    "eslint": "^4.14.0",
     "eslint-config-airbnb-base": "^12.1.0",
     "eslint-plugin-import": "^2.8.0",
     "istanbul": "^v1.1.0-alpha.1",
     "mocha": "^4.0.1",
-    "mochawesome": "^2.3.1",
-    "nyc": "^11.2.1",
-    "ts-node": "^3.3.0",
+    "mochawesome": "^3.0.0",
+    "nyc": "^11.4.1",
+    "ts-node": "^4.1.0",
     "tslint": "^5.8.0",
-    "typescript": "^2.5.3",
-    "webpack": "^3.8.1",
+    "typescript": "^2.6.2",
+    "webpack": "^3.10.0",
     "yargs": "^10.0.3"
   }
 }

src/js/algorithms/sorting/bubble-sort-improved.js

@@ -0,0 +1,16 @@
+import { Compare, defaultCompare, swap } from '../../util';
+
+export function modifiedBubbleSort(array, compareFn = defaultCompare) {
+  const { length } = array;
+  for (let i = 0; i < length; i++) {
+    // console.log('--- ');
+    for (let j = 0; j < length - 1 - i; j++) {
+      // console.log('compare ' + array[j] + ' with ' + array[j + 1]);
+      if (compareFn(array[j], array[j + 1]) === Compare.BIGGER_THAN) {
+        // console.log('swap ' + array[j] + ' with ' + array[j + 1]);
+        swap(array, j, j + 1);
+      }
+    }
+  }
+  return array;
+}

src/js/algorithms/sorting/bubble-sort.js

@@ -0,0 +1,16 @@
+import { Compare, defaultCompare, swap } from '../../util';
+
+export function bubbleSort(array, compareFn = defaultCompare) {
+  const { length } = array;
+  for (let i = 0; i < length; i++) {
+    // console.log('--- ');
+    for (let j = 0; j < length - 1; j++) {
+      // console.log('compare ' + array[j] + ' with ' + array[j + 1]);
+      if (compareFn(array[j], array[j + 1]) === Compare.BIGGER_THAN) {
+        // console.log('swap ' + array[j] + ' with ' + array[j + 1]);
+        swap(array, j, j + 1);
+      }
+    }
+  }
+  return array;
+}

src/js/algorithms/sorting/insertion-sort.js

@@ -0,0 +1,19 @@
+import { Compare, defaultCompare } from '../../util';
+
+export const insertionSort = (array, compareFn = defaultCompare) => {
+  const { length } = array;
+  let temp;
+  for (let i = 1; i < length; i++) {
+    let j = i;
+    temp = array[i];
+    // console.log('to be inserted ' + temp);
+    while (j > 0 && compareFn(array[j - 1], temp) === Compare.BIGGER_THAN) {
+      // console.log('shift ' + array[j - 1]);
+      array[j] = array[j - 1];
+      j--;
+    }
+    // console.log('insert ' + temp);
+    array[j] = temp;
+  }
+  return array;
+};

src/js/algorithms/sorting/merge-sort.js

@@ -0,0 +1,21 @@
+import { Compare, defaultCompare } from '../../util';
+
+function merge(left, right, compareFn) {
+  let i = 0;
+  let j = 0;
+  const result = [];
+  while (i < left.length && j < right.length) {
+    result.push(compareFn(left[i], right[j]) === Compare.LESS_THAN ? left[i++] : right[j++]);
+  }
+  return result.concat(i < left.length ? left.slice(i) : right.slice(j));
+}
+export function mergeSort(array, compareFn = defaultCompare) {
+  if (array.length > 1) {
+    const { length } = array;
+    const middle = Math.floor(length / 2);
+    const left = mergeSort(array.slice(0, middle), compareFn);
+    const right = mergeSort(array.slice(middle, length), compareFn);
+    array = merge(left, right, compareFn);
+  }
+  return array;
+}

src/js/algorithms/sorting/quicksort.js

@@ -0,0 +1,41 @@
+import { Compare, defaultCompare, swap } from '../../util';
+
+function partition(array, left, right, compareFn) {
+  const pivot = array[Math.floor((right + left) / 2)];
+  let i = left;
+  let j = right;
+  // console.log('pivot is ' + pivot + '; left is ' + left + '; right is ' + right);
+  while (i <= j) {
+    while (compareFn(array[i], pivot) === Compare.LESS_THAN) {
+      i++;
+      // console.log('i = ' + i);
+    }
+    while (compareFn(array[j], pivot) === Compare.BIGGER_THAN) {
+      j--;
+      // console.log('j = ' + j);
+    }
+    if (i <= j) {
+      // console.log('swap ' + array[i] + ' with ' + array[j]);
+      swap(array, i, j);
+      i++;
+      j--;
+    }
+  }
+  return i;
+}
+function quick(array, left, right, compareFn) {
+  let index;
+  if (array.length > 1) {
+    index = partition(array, left, right, compareFn);
+    if (left < index - 1) {
+      quick(array, left, index - 1, compareFn);
+    }
+    if (index < right) {
+      quick(array, index, right, compareFn);
+    }
+  }
+  return array;
+}
+export function quickSort(array, compareFn = defaultCompare) {
+  return quick(array, 0, array.length - 1, compareFn);
+}

src/js/algorithms/sorting/selection-sort.js

@@ -0,0 +1,21 @@
+import { Compare, defaultCompare, swap } from '../../util';
+
+export const selectionSort = (array, compareFn = defaultCompare) => {
+  const { length } = array;
+  let indexMin;
+  for (let i = 0; i < length - 1; i++) {
+    indexMin = i;
+    // console.log('index ' + array[i]);
+    for (let j = i; j < length; j++) {
+      if (compareFn(array[indexMin], array[j]) === Compare.BIGGER_THAN) {
+        // console.log('new index min ' + array[j]);
+        indexMin = j;
+      }
+    }
+    if (i !== indexMin) {
+      // console.log('swap ' + array[i] + ' with ' + array[indexMin]);
+      swap(array, i, indexMin);
+    }
+  }
+  return array;
+};

src/js/algorithms/sorting/shell-sort.js

@@ -0,0 +1,22 @@
+import { Compare, defaultCompare } from '../../util';
+
+export function shellSort(array, compareFn = defaultCompare) {
+  let increment = array.length / 2;
+  while (increment > 0) {
+    for (let i = increment; i < array.length; i++) {
+      let j = i;
+      const temp = array[i];
+      while (j >= increment && compareFn(array[j - increment], temp) === Compare.BIGGER_THAN) {
+        array[j] = array[j - increment];
+        j -= increment;
+      }
+      array[j] = temp;
+    }
+    if (increment === 2) {
+      increment = 1;
+    } else {
+      increment = Math.floor((increment * 5) / 11);
+    }
+  }
+  return array;
+}