initial commit

sort/insertion-debug.js

@@ -0,0 +1,23 @@
+'use strict';
+
+import _ from '../utils';
+
+let arr = _.args.numbers();
+
+for(let i = 1, len = arr.length; i < len; i++) {
+  let key = arr[i];
+  let j = i - 1;
+  _.debug(`on arr[${i}] = ${key}`);
+
+  while(j > -1 && arr[j] > key) {
+    _.debug(` - a[${j}] = ${arr[j]} > ${key}`);
+
+    arr[j + 1] = arr[j];
+    j--;
+  }
+
+  _.debug(` - moving key = ${key} to arr[${j+1}]`);
+  arr[j + 1] = key;
+}
+
+_.log(arr.join(' '));

sort/insertion-optimizied-binarySearch-debug.js

@@ -0,0 +1,33 @@
+'use strict';
+
+let _ = require('../utils'),
+    binarySearch = require('../search/binary-recursive');
+
+let arr = _.args.numbers();
+
+for(let i = 1, len = arr.length; i < len; i++) {
+  let key = arr[i];
+  let j = -1,
+      x = 1;
+
+  _.debug(`at ${key}`);
+  do {
+    let end = i - (x-1);
+    _.debug(` - looking for ${key + x} in ${arr.slice(0, end)}`);
+    j = binarySearch(key + x++, arr, 0, end);
+  } while (j === -1 && end > -1);
+
+  if(j === -1) {
+    _.debug('j not found, continuing');
+    continue;
+  }
+
+  for(let c = i-1; c >= j; c--) {
+    arr[c+1] = arr[c];
+    _.debug(` - arr[${c+1}] = arr[${c}]`);
+  }
+
+  arr[j] = key;
+}
+
+_.log(arr.join(' '));

sort/insertion-optimizied-binarySearch.js

@@ -0,0 +1,27 @@
+'use strict';
+
+let _ = require('../utils'),
+    binarySearch = require('../search/binary-recursive');
+
+let arr = _.args.numbers();
+
+for(let i = 1, len = arr.length; i < len; i++) {
+  let key = arr[i];
+  let j = -1,
+      x = 1;
+
+  do {
+    let end = i - (x-1);
+    j = binarySearch(key + x++, arr, 0, end);
+  } while (j === -1 && end > -1);
+
+  if(j === -1) continue;
+  
+  for(let c = i-1; c >= j; c--) {
+    arr[c+1] = arr[c];
+  }
+
+  arr[j] = key;
+}
+
+_.log(arr.join(' '));

sort/insertion-recursive-debug.js

@@ -0,0 +1,27 @@
+'use strict';
+
+import _ from '../utils';
+
+let arr = _.args.numbers();
+
+function insertionSort(arr, n) {
+  _.debug(`insertionSort(arr, ${n})`);
+
+  if(n > 0) insertionSort(arr, n-1);
+
+  _.debug(`sorting 0...${n}`);
+
+  let o = arr[n],
+      i = n-1;
+  while(arr[i] > o) {
+    arr[i+1] = arr[i];
+    _.debug(` - moving arr[${i}] to arr[${i+1}]`);
+    i--;
+  }
+  arr[i+1] = o;
+  _.debug(` - arr[${i}] set to ${o}`);
+}
+
+insertionSort(arr, arr.length-1);
+
+_.log(arr.join(' '));

sort/insertion-recursive.js

@@ -0,0 +1,20 @@
+'use strict';
+
+import _ from '../utils';
+
+let arr = _.args.numbers();
+
+function insertionSort(arr, n) {
+  if(n > 0) insertionSort(arr, n-1);
+  let o = arr[n],
+      i = n-1;
+  while(arr[i] > o) {
+    arr[i+1] = arr[i];
+    i--;
+  }
+  arr[i+1] = o;
+}
+
+insertionSort(arr, arr.length-1);
+
+_.log(arr.join(' '));

sort/insertion.js

@@ -0,0 +1,19 @@
+'use strict';
+
+import _ from '../utils';
+
+let arr = _.args.numbers();
+
+for(let i = 1, len = arr.length; i < len; i++) {
+  let key = arr[i];
+  let j = i - 1;
+
+  while(j > -1 && arr[j] > key) {
+    arr[j + 1] = arr[j];
+    j--;
+  }
+
+  arr[j + 1] = key;
+}
+
+_.log(arr.join(' '));

sort/merge-debug.js

@@ -0,0 +1,49 @@
+'use strict';
+import _ from '../utils';
+
+let arr = _.args.numbers();
+
+mergeSort(arr, 0, arr.length);
+_.log(arr.join(' '));
+
+function mergeSort(a, p, r) {
+  if(r - p === 1) return;
+
+  let q = Math.floor((r+p)/2);
+  _.debug(`mergeSort(${[p, q, r]})`);
+
+  mergeSort(a, p, q);
+  mergeSort(a, q, r);
+  merge(a, p, q, r);
+}
+
+function merge(a, p, q, r) {
+  _.debug(`- merge(${[p, q, r]})`);
+
+  let i = 0,
+      j = 0;
+
+  let left = a.slice(p, q),
+      right = a.slice(q, r);
+
+  _.debug(`  - left = [${left}]`);
+  _.debug(`  - right = [${right}]`);
+
+  left.push(Infinity);
+  right.push(Infinity);
+
+  for(let k = p; k < r; k++) {
+    if(left[i] <= right[j]) {
+      a[k] = left[i];
+      _.debug(`  - set a[${k}] = (left[${i}]=${left[i]})`);
+
+      i++;
+    } else {
+      a[k] = right[j];
+      _.debug(`  - set a[${k}] = (right[${j}]=${right[j]})`);
+
+      j++;
+    }
+  }
+  _.debug(`a = [${a}]`);
+}

sort/merge.js

@@ -0,0 +1,42 @@
+'use strict';
+import _ from '../utils';
+
+let arr = _.args.numbers();
+
+function mergeSort(a, p, r) {
+  if(r - p === 1) return;
+
+  let q = Math.floor((r+p)/2);
+
+  mergeSort(a, p, q);
+  mergeSort(a, q, r);
+  merge(a, p, q, r);
+}
+
+function merge(a, p, q, r) {
+  let i = 0,
+      j = 0;
+
+  let left = a.slice(p, q),
+      right = a.slice(q, r);
+
+  left.push(Infinity);
+  right.push(Infinity);
+
+  for(let k = p; k < r; k++) {
+    if(left[i] <= right[j]) {
+      a[k] = left[i];
+      i++;
+    } else {
+      a[k] = right[j];
+      j++;
+    }
+  }
+}
+
+if (require.main === module) {
+  mergeSort(arr, 0, arr.length);
+  _.log(arr.join(' '));
+}
+
+module.exports = mergeSort;

sort/quick.js

@@ -0,0 +1,49 @@
+'use strict';
+import _ from '../utils';
+
+let arr = _.args.numbers();
+
+function quickSort(array, p = 0, r = array.length) {
+  if (p >= r) return;
+
+  let pivot = partition(array, p, r);
+
+  // pivot is not included
+  quickSort(array, p, pivot - 1);
+  quickSort(array, pivot + 1, r);
+}
+
+function partition(array, p, r) {
+  let q = p;
+
+  // start at p, if any element is bigger than pivot, it will automatically
+  // be added to RIGHT group as the u increases,
+  // if it's less than pivot, it will be added to LEFT by swapping it
+  // with the leftmost element of RIGHT group, and moving RIGHT's starting point
+  // (q) one point to right
+  for (let u = p; u < r; u++) {
+    if (array[u] <= array[r]) {
+      swap(array, u, q);
+
+      q++;
+    }
+  }
+
+  // after finding LEFT and RIGHT groups, move pivot to it's original position
+  swap(array, r, q);
+
+  return q;
+}
+
+function swap(array, a, b) {
+  let tmp = array[b];
+  array[b] = array[a];
+  array[a] = tmp;
+}
+
+if (require.main === module) {
+  quickSort(arr, 0, arr.length);
+  _.log(arr.join(' '));
+}
+
+module.exports = quickSort;

sort/selection-debug.js

@@ -0,0 +1,29 @@
+'use strict';
+
+import _ from '../utils';
+
+let arr = _.args.numbers();
+
+for(let i = 0, len = arr.length; i < len-1; i++) {
+  let min = i;
+
+  _.debug(`on arr[${i}]; min=${arr[min]} minIndex=${min}`);
+
+  for(let j = i+1; j < len; j++) {
+    _.debug(` - comparing with arr[${j}] = ${arr[j]}`);
+
+    if(arr[j] < arr[min]) {
+      min = j;
+
+      _.debug(` - found a new minimum; min=${arr[j]} minIndex=${min}`);
+    }
+  }
+
+  _.debug(` - swapping arr[${min}]=${arr[min]} with arr[${i}]=${arr[i]}`);
+
+  let tmp = arr[min];
+  arr[min] = arr[i];
+  arr[i] = tmp;
+}
+
+_.log(arr.join(' '));

sort/selection.js

@@ -0,0 +1,21 @@
+'use strict';
+
+import _ from '../utils';
+
+let arr = _.args.numbers();
+
+for(let i = 0, len = arr.length; i < len-1; i++) {
+  let min = i;
+
+  for(let j = i+1; j < len; j++) {
+    if(arr[j] < arr[min]) {
+      min = j;
+    }
+  }
+
+  let tmp = arr[min];
+  arr[min] = arr[i];
+  arr[i] = tmp;
+}
+
+_.log(arr.join(' '));