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;
+}

src/ts/algorithms/search/binary-search.ts

@@ -0,0 +1,25 @@
+import { Compare, defaultCompare, DOES_NOT_EXIST } from '../../util';
+import { quickSort } from '../sorting/quicksort';
+
+export function binarySearch<T> (array: T[], value: T, compareFn = defaultCompare) {
+  const sortedArray = quickSort(array);
+  let low = 0;
+  let high = sortedArray.length - 1;
+
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const element = sortedArray[mid];
+    // console.log('mid element is ' + element);
+    if (compareFn(element, value) === Compare.LESS_THAN) {
+      low = mid + 1;
+      // console.log('low is ' + low);
+    } else if (compareFn(element, value) === Compare.BIGGER_THAN) {
+      high = mid - 1;
+      // console.log('high is ' + high);
+    } else {
+      // console.log('found it');
+      return mid;
+    }
+  }
+  return DOES_NOT_EXIST;
+}

src/ts/algorithms/search/interpolation-search.ts

@@ -0,0 +1,41 @@
+import {
+  biggerEquals,
+  Compare,
+  defaultCompare,
+  defaultEquals,
+  defaultDiff,
+  DOES_NOT_EXIST,
+  lesserEquals
+} from '../../util';
+
+export function interpolationSearch<T>(
+  array: T[],
+  value: T,
+  compareFn = defaultCompare,
+  equalsFn = defaultEquals,
+  diffFn = defaultDiff
+) {
+  const { length } = array;
+  let low = 0;
+  let high = length - 1;
+  let position = -1;
+  let delta = -1;
+  while (
+    low <= high &&
+    biggerEquals(value, array[low], compareFn) &&
+    lesserEquals(value, array[high], compareFn)
+  ) {
+    delta = diffFn(value, array[low]) / diffFn(array[high], array[low]);
+    position = low + Math.floor((high - low) * delta);
+    if (equalsFn(array[position], value)) {
+      return position;
+    }
+    if (compareFn(array[position], value) === Compare.LESS_THAN) {
+      low = position + 1;
+    } else {
+      high = position - 1;
+    }
+  }
+
+  return DOES_NOT_EXIST;
+}

src/ts/algorithms/search/min-max-search.ts

@@ -0,0 +1,27 @@
+import { defaultCompare, Compare } from '../../util';
+
+export function findMaxValue<T>(array: T[], compareFn = defaultCompare) {
+  if (array && array.length > 0) {
+    let max = array[0];
+    for (let i = 1; i < array.length; i++) {
+      if (compareFn(max, array[i]) === Compare.LESS_THAN) {
+        max = array[i];
+      }
+    }
+    return max;
+  }
+  return undefined;
+}
+
+export function findMinValue<T>(array: T[], compareFn = defaultCompare) {
+  if (array && array.length > 0) {
+    let min = array[0];
+    for (let i = 1; i < array.length; i++) {
+      if (compareFn(min, array[i]) === Compare.BIGGER_THAN) {
+        min = array[i];
+      }
+    }
+    return min;
+  }
+  return undefined;
+}

src/ts/algorithms/search/sequential-search.ts

@@ -0,0 +1,10 @@
+import { defaultEquals, DOES_NOT_EXIST, IEqualsFunction } from '../../util';
+
+export function sequentialSearch<T>(array: T[], value: T, equalsFn: IEqualsFunction<T> = defaultEquals) {
+  for (let i = 0; i < array.length; i++) {
+    if (equalsFn(value, array[i])) {
+      return i;
+    }
+  }
+  return DOES_NOT_EXIST;
+}

src/ts/algorithms/shuffle/fisher–yates.ts

@@ -0,0 +1,13 @@
+import { swap } from '../../util';
+
+export function shuffle<T>(array: T[]) {
+  let currentIndex = array.length;
+
+  while (currentIndex !== 0) {
+    const randomIndex = Math.floor(Math.random() * currentIndex);
+    currentIndex--;
+    swap(array, currentIndex, randomIndex);
+  }
+
+  return array;
+}

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

@@ -0,0 +1,18 @@
+import { Compare, defaultCompare, swap } from '../../util';
+
+export function modifiedBubbleSort<T>(array: T[], 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/ts/algorithms/sorting/bubble-sort.ts

@@ -0,0 +1,18 @@
+import { Compare, defaultCompare, swap } from '../../util';
+
+export function bubbleSort<T>(array: T[], 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;
+}