[Sorting and Searching Algorithms]

Author: loiane

examples/PacktDataStructuresAlgorithms.min.js

@@ -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  --recursive --reporter mochawesome",
+    "test:ts": "mocha -r ts-node/register ./test/ts/**/*.spec.ts ./test/ts/**/**/*.spec.ts --recursive",
     "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",

package.json

@@ -0,0 +1,24 @@
+import { Compare, defaultCompare, DOES_NOT_EXIST } from '../../util';
+import { quickSort } from '../sorting/quicksort';
+
+export function binarySearch(array, value, 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/js/algorithms/search/binary-search.js

@@ -0,0 +1,40 @@
+import {
+  biggerEquals,
+  Compare,
+  defaultCompare,
+  defaultEquals,
+  defaultDiff,
+  DOES_NOT_EXIST,
+  lesserEquals
+} from '../../util';
+
+export function interpolationSearch(
+  array,
+  value,
+  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/js/algorithms/search/interpolation-search.js

@@ -0,0 +1,26 @@
+import { defaultCompare, Compare } from '../../util';
+
+export function findMaxValue(array, 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(array, 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/js/algorithms/search/min-max-search.js

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

src/js/algorithms/search/sequential-search.js

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

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

@@ -0,0 +1,41 @@
+import { insertionSort } from './insertion-sort';
+
+function createBuckets(array, bucketSize) {
+  let minValue = array[0];
+  let maxValue = array[0];
+  for (let i = 1; i < array.length; i++) {
+    if (array[i] < minValue) {
+      minValue = array[i];
+    } else if (array[i] > maxValue) {
+      maxValue = array[i];
+    }
+  }
+  const bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;
+  const buckets = [];
+  for (let i = 0; i < bucketCount; i++) {
+    buckets[i] = [];
+  }
+  for (let i = 0; i < array.length; i++) {
+    buckets[Math.floor((array[i] - minValue) / bucketSize)].push(array[i]);
+  }
+  return buckets;
+}
+function sortBuckets(buckets) {
+  const sortedArray = [];
+  for (let i = 0; i < buckets.length; i++) {
+    if (buckets[i] != null) {
+      insertionSort(buckets[i]);
+      for (let j = 0; j < buckets[i].length; j++) {
+        sortedArray.push(buckets[i][j]);
+      }
+    }
+  }
+  return sortedArray;
+}
+export function bucketSort(array, bucketSize = 5) {
+  if (array.length < 2) {
+    return array;
+  }
+  const buckets = createBuckets(array, bucketSize);
+  return sortBuckets(buckets);
+}

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

@@ -0,0 +1,24 @@
+import { findMaxValue } from '../search/min-max-search';
+
+export function countingSort(array) {
+  if (array.length < 2) {
+    return array;
+  }
+  const maxValue = findMaxValue(array);
+  let sortedIndex = 0;
+  const counts = new Array(maxValue + 1);
+  array.forEach(element => {
+    if (!counts[element]) {
+      counts[element] = 0;
+    }
+    counts[element]++;
+  });
+  // console.log('Frequencies: ' + counts.join());
+  counts.forEach((element, i) => {
+    while (element > 0) {
+      array[sortedIndex++] = i;
+      element--;
+    }
+  });
+  return array;
+}

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

@@ -0,0 +1,41 @@
+import { findMaxValue, findMinValue } from '../search/min-max-search';
+
+const countingSortForRadix = (array, radixBase, significantDigit, minValue) => {
+  let bucketsIndex;
+  const buckets = [];
+  const aux = [];
+  for (let i = 0; i < radixBase; i++) {
+    buckets[i] = 0;
+  }
+  for (let i = 0; i < array.length; i++) {
+    bucketsIndex = Math.floor(((array[i] - minValue) / significantDigit) % radixBase);
+    buckets[bucketsIndex]++;
+  }
+  for (let i = 1; i < radixBase; i++) {
+    buckets[i] += buckets[i - 1];
+  }
+  for (let i = array.length - 1; i >= 0; i--) {
+    bucketsIndex = Math.floor(((array[i] - minValue) / significantDigit) % radixBase);
+    aux[--buckets[bucketsIndex]] = array[i];
+  }
+  for (let i = 0; i < array.length; i++) {
+    array[i] = aux[i];
+  }
+  return array;
+};
+export function radixSort(array, radixBase = 10) {
+  if (array.length < 2) {
+    return array;
+  }
+  const minValue = findMinValue(array);
+  const maxValue = findMaxValue(array);
+  // Perform counting sort for each significant digit, starting at 1
+  let significantDigit = 1;
+  while ((maxValue - minValue) / significantDigit >= 1) {
+    // console.log('radix sort for digit ' + significantDigit);
+    array = countingSortForRadix(array, radixBase, significantDigit, minValue);
+    // console.log(array.join());
+    significantDigit *= radixBase;
+  }
+  return array;
+}

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

@@ -61,3 +61,23 @@ export { dijkstra } from './algorithms/graph/dijkstra';
 export { floydWarshall } from './algorithms/graph/floyd-warshall';
 export { prim } from './algorithms/graph/prim';
 export { kruskal } from './algorithms/graph/kruskal';
+
+// chapter 12
+export { shuffle } from './algorithms/shuffle/fisher–yates';
+
+export { bubbleSort } from './algorithms/sorting/bubble-sort';
+export { modifiedBubbleSort } from './algorithms/sorting/bubble-sort-improved';
+export { bucketSort } from './algorithms/sorting/bucket-sort';
+export { countingSort } from './algorithms/sorting/counting-sort';
+export { insertionSort } from './algorithms/sorting/insertion-sort';
+export { mergeSort } from './algorithms/sorting/merge-sort';
+export { quickSort } from './algorithms/sorting/quicksort';
+export { radixSort } from './algorithms/sorting/radix-sort';
+export { selectionSort } from './algorithms/sorting/selection-sort';
+export { shellSort } from './algorithms/sorting/shell-sort';
+
+export { binarySearch } from './algorithms/search/binary-search';
+export { interpolationSearch } from './algorithms/search/interpolation-search';
+export { sequentialSearch } from './algorithms/search/sequential-search';
+export { findMaxValue } from './algorithms/search/min-max-search';
+export { findMinValue } from './algorithms/search/min-max-search';

src/js/index.js

@@ -1,8 +1,21 @@
 export const Compare = {
   LESS_THAN: -1,
-  BIGGER_THAN: 1
+  BIGGER_THAN: 1,
+  EQUALS: 0
 };
 
+export const DOES_NOT_EXIST = -1;
+
+export function lesserEquals(a, b, compareFn) {
+  const comp = compareFn(a, b);
+  return comp === Compare.LESS_THAN || comp === Compare.EQUALS;
+}
+
+export function biggerEquals(a, b, compareFn) {
+  const comp = compareFn(a, b);
+  return comp === Compare.BIGGER_THAN || comp === Compare.EQUALS;
+}
+
 export function defaultCompare(a, b) {
   if (a === b) {
     return 0;
@@ -34,3 +47,7 @@ export function swap(array, a, b) {
 export function reverseCompare(compareFn) {
   return (a, b) => compareFn(b, a);
 }
+
+export function defaultDiff(a, b) {
+  return Number(a) - Number(b);
+}

src/js/util.js

@@ -1,4 +1,4 @@
-import { findMaxValue } from '../..';
+import { findMaxValue } from '../search/min-max-search';
 
 export function countingSort(array: number[]) {
 

src/ts/algorithms/sorting/counting-sort.ts

@@ -0,0 +1,4 @@
+import { binarySearch } from '../../../../src/js/index';
+import { testSearchAlgorithm } from './search-algorithms-tests';
+
+testSearchAlgorithm(binarySearch, 'Binary Search');

test/js/algorithms/search/binary-search.spec.js

@@ -0,0 +1,4 @@
+import { interpolationSearch } from '../../../../src/js/index';
+import { testSearchAlgorithm } from './search-algorithms-tests';
+
+testSearchAlgorithm(interpolationSearch, 'Interpolation Search', { customEquals: false });

test/js/algorithms/search/interpolation-search.spec.js

@@ -0,0 +1,31 @@
+import 'mocha';
+import { expect } from 'chai';
+import { findMinValue, findMaxValue } from '../../../../src/js/index';
+
+describe('Min and Max Values Search', () => {
+  const SIZE = 10;
+
+  function createSortedArray() {
+    const array = [];
+    for (let i = 1; i <= SIZE; i++) {
+      array.push(i);
+    }
+    return array;
+  }
+
+  it('min value - works with empty arrays', () => {
+    expect(findMinValue([])).to.equal(undefined);
+  });
+
+  it('max value - works with empty arrays', () => {
+    expect(findMaxValue([])).to.equal(undefined);
+  });
+
+  it('min value', () => {
+    expect(findMinValue(createSortedArray())).to.equal(1);
+  });
+
+  it('max value', () => {
+    expect(findMaxValue(createSortedArray())).to.equal(SIZE);
+  });
+});

test/js/algorithms/search/min-max-search.spec.js

@@ -0,0 +1,43 @@
+import 'mocha';
+import { expect } from 'chai';
+
+const customEquals = (a, b) => a.key === b.key;
+
+export function testSearchAlgorithm(
+  searchAlgorithm,
+  algorithmName,
+  config = { customEquals: true }
+) {
+  describe(algorithmName, () => {
+    const SIZE = 10;
+
+    function createSortedArray() {
+      const array = [];
+      for (let i = 1; i <= SIZE; i++) {
+        array.push(i);
+      }
+      return array;
+    }
+
+    it('works with empty arrays', () => {
+      expect(searchAlgorithm([], 1)).to.equal(-1);
+    });
+
+    it('finds value at the first position', () => {
+      const array = createSortedArray();
+      expect(searchAlgorithm(array, 1)).to.equal(0);
+    });
+
+    it('finds value at the last position', () => {
+      const array = createSortedArray();
+      expect(searchAlgorithm(array, SIZE)).to.equal(SIZE - 1);
+    });
+
+    if (config.customEquals) {
+      it('finds value with custom equals function', () => {
+        const array = [{ key: 1 }, { key: 2 }, { key: 3 }];
+        expect(searchAlgorithm(array, { key: 2 }, customEquals)).to.equal(1);
+      });
+    }
+  });
+}

test/js/algorithms/search/search-algorithms-tests.js

@@ -0,0 +1,4 @@
+import { sequentialSearch } from '../../../../src/js/index';
+import { testSearchAlgorithm } from './search-algorithms-tests';
+
+testSearchAlgorithm(sequentialSearch, 'Sequential Search');