Merge branch 'tayllan-master'

felipernb · felipernb · commit 6cfc03971aee · 2014-06-06T23:38:57.000+02:00
diff --git a/algorithms/graph/depth_first_search.js b/algorithms/graph/depth_first_search.js
@@ -0,0 +1,73 @@
+/**
+ * Copyright (C) 2014 Tayllan Búrigo
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"], to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+'use strict';
+
+var time = 0,
+    visitedNodes = {},
+    finishingTimes = {};
+    
+/**
+ * Depth First Search for all the vertices in the graph
+ * Worst Case Complexity: O(V * E)
+ * 
+ * @param {Object}
+ * @return {Object} representing the order in which the
+ *    vertices are visited
+ */
+var dfsAdjacencyListStart = function (graph) {
+  graph.vertices.forEach(function (v) {
+    if (visitedNodes[v] !== true) {
+      dfsAdjacencyList(graph, v);
+    }
+  });
+
+  return finishingTimes;
+};
+
+/**
+ * Depth First Search for the vertices reachable from 'startNode'
+ * Worst Case Complexity: O(V * E)
+ * 
+ * @param {Object}
+ * @param {Object}
+ * @return {Object}
+ */
+var dfsAdjacencyList = function (graph, startNode) {
+  visitedNodes[startNode] = true;
+
+  graph.neighbors(startNode).forEach(function (v) {
+    if (visitedNodes[v] !== true) {
+      dfsAdjacencyList(graph, v);
+    }
+  });
+
+  finishingTimes[startNode] = time++;
+
+  return finishingTimes;
+};
+
+var depthFirstSearch = {
+  dfsAdjacencyList: dfsAdjacencyList,
+  dfsAdjacencyListStart: dfsAdjacencyListStart
+};
+
+module.exports = depthFirstSearch;
diff --git a/algorithms/sorting/radix_sort.js b/algorithms/sorting/radix_sort.js
@@ -0,0 +1,146 @@
+/**
+ * Copyright (C) 2014 Tayllan Búrigo
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+'use strict';
+
+/**
+ * Sorts an array of objects according to their 'key' property
+ * Every object inside the array MUST have the 'key' property with
+ * a integer value.
+ *
+ * Asymptotic Complexity: O(array.length * d), where 'd' represents
+ * the amount of digits in the larger key of the array
+ *
+ * @param Array
+ * @return Array
+ */
+var radixSort = function (array) {
+  var max = maximumKey(array);
+  var digitsMax = amountOfDigits(max);
+
+  for (var i = 0; i < digitsMax; i++) {
+    array = auxiliaryCountingSort(array, i);
+  }
+
+  return array;
+};
+
+/**
+ * Auxiliary sorting method for RadixSort
+ * Sorts an array of objects according to only one digit of
+ * their 'key' property. The digit to be sorted is determined
+ * by the 'mod' variable
+ * Every object inside the array MUST have the 'key' property with
+ * a integer value.
+ *
+ * Execution Time: (2 * array.length + 10)
+ * Asymptotic Complexity: O(array.length)
+ *
+ * @param Array
+ * @return Array
+ */
+var auxiliaryCountingSort = function (array, mod) {
+  var length = array.length;
+  var bucket = [];
+
+  for (var i = 0; i < 10; i++) {
+    bucket[i] = [];
+  }
+
+  for (i = 0; i < length; i++) {
+    var digit = parseInt((array[i].key / Math.pow(10, mod)).toFixed(mod)) % 10;
+    bucket[digit].push(array[i]);
+  }
+
+  var pointer = 0;
+
+  for (i = 0; i < 10; i++) {
+    var localLength = bucket[i].length;
+
+    for (var j = 0; j < localLength; j++) {
+      array[pointer++] = bucket[i][j];
+    }
+  }
+
+  return array;
+};
+
+/**
+ * Finds the maximum key from an array of objects
+ *
+ * Asymptotic Complexity: O(array.length)
+ *
+ * @param Array
+ * @return Integer if array non-empty
+ *         Undefined otherwise
+ */
+var maximumKey = function (array) {
+  var length = array.length;
+
+  if (length > 0) {
+    var max = array[0].key;
+
+    for (var i = 1; i < length; i++) {
+      if (array[i].key > max) {
+        max = array[i].key;
+      }
+    }
+
+    return max;
+  }
+  else {
+    return undefined;
+  }
+};
+
+/**
+ * Returns the amount of digits contained in a number
+ * 
+ * Asymptotic Complexity: O(d), where 'd' represents the
+ * amount of digits in the number
+ * 
+ * @param Number
+ * @return Number
+ */
+var amountOfDigits = function (number) {
+  if (number === 0) {
+    return 1;
+  }
+  else {
+    var counter = 0;
+
+    // For positive numbers
+    while (parseInt(number) > 0) {
+      number /= 10;
+      ++counter;
+    }
+
+    // For negative numbers
+    while (parseInt(number) < 0) {
+      number /= 10;
+      ++counter;
+    }
+
+    return counter;
+  }
+};
+
+module.exports = radixSort;
diff --git a/main.js b/main.js
@@ -28,6 +28,7 @@ var lib = {
     SPFA: require('./algorithms/graph/SPFA'),
     bellmanFord: require('./algorithms/graph/bellman_ford'),
     eulerPath: require('./algorithms/graph/euler_path'),
+    depthFirstSearch: require('./algorithms/graph/depth_first_search')
   },
   Math: {
     fibonacci: require('./algorithms/math/fibonacci'),
@@ -47,7 +48,8 @@ var lib = {
     heapSort: require('./algorithms/sorting/heap_sort'),
     mergeSort: require('./algorithms/sorting/merge_sort'),
     quicksort: require('./algorithms/sorting/quicksort'),
-    selectionSort: require('./algorithms/sorting/selection_sort')
+    selectionSort: require('./algorithms/sorting/selection_sort'),
+    radixSort: require('./algorithms/sorting/radix_sort')
   },
   String: {
     editDistance: require('./algorithms/string/edit_distance'),
diff --git a/test/algorithms/graph/depth_first_search.js b/test/algorithms/graph/depth_first_search.js
@@ -0,0 +1,64 @@
+/**
+ * Copyright (C) 2014 Tayllan Búrigo
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"], to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+'use strict';
+
+var depthFirstSearch = require('../../../algorithms/graph/depth_first_search'),
+    Graph = require('../../../data_structures/graph'),
+    assert = require('assert'),
+    graph = new Graph(true);
+
+graph.addEdge('one', 'three');
+graph.addEdge('one', 'four');
+graph.addEdge('four', 'two');
+graph.addEdge('two', 'one');
+graph.addEdge('three', 'one');
+graph.addEdge('five', 'six');
+
+describe('Depth First Search Algorithm', function () {
+  it('should visit only the nodes reachable from the node {one} (inclusive)',
+    function () {
+      var finishingTimes = depthFirstSearch.dfsAdjacencyList(graph, 'one');
+
+      assert.equal(finishingTimes.five, undefined);
+      assert.equal(finishingTimes.six, undefined);
+
+      assert.equal(finishingTimes.one, 3);
+      assert.equal(finishingTimes.two, 1);
+      assert.equal(finishingTimes.three, 0);
+      assert.equal(finishingTimes.four, 2);
+    }
+  );
+
+  it('should visit all the nodes in the graph',
+    function () {
+      var finishingTimes = depthFirstSearch.dfsAdjacencyListStart(graph);
+
+      assert.equal(finishingTimes.one, 3);
+      assert.equal(finishingTimes.two, 1);
+      assert.equal(finishingTimes.three, 0);
+      assert.equal(finishingTimes.four, 2);
+      assert.equal(finishingTimes.five, 5);
+      assert.equal(finishingTimes.six, 4);
+    }
+  );
+});
+
diff --git a/test/algorithms/sorting/radix_sort.js b/test/algorithms/sorting/radix_sort.js
@@ -0,0 +1,70 @@
+/**
+ * Copyright (C) 2014 Tayllan Búrigo
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"], to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+'use strict';
+
+var radixSort = require('../../../algorithms/sorting/radix_sort'),
+    assert = require('assert');
+
+var firstObject = {
+  someProperty: 'The',
+  key: 88541234132
+};
+
+var secondObject = {
+  someProperty: 'winter',
+  key: 90071992540992
+};
+
+var thirdObject = {
+  someProperty: 'is',
+  key: 0
+};
+
+var fourthObject = {
+  someProperty: 'coming',
+  key: 65234567,
+  anotherProperty: '!'
+};
+
+var array = [
+  thirdObject,
+  fourthObject,
+  firstObject,
+  secondObject,
+  secondObject,
+  firstObject,
+  firstObject,
+  fourthObject
+];
+
+describe('Radix Sort', function () {
+  it('should sort the given array', function () {
+    array = radixSort(array);
+
+    // Asserts that the array is truly sorted
+    assert.deepEqual(array.indexOf(thirdObject), 0);
+    assert.deepEqual(array.indexOf(fourthObject), 1);
+    assert.deepEqual(array.indexOf(firstObject), 3);
+    assert.deepEqual(array.indexOf(secondObject), 6);
+    assert.deepEqual(array.indexOf({key: 99}), -1);
+  });
+});
