New dfs implementation

Author: mgechev

src/graphs/searching/dfs.js

@@ -1,129 +1,54 @@
-'use strict';
-
-/* * * * * * * * * * * * * * * * * *
-
-        Sample graph
-
-var graph = [[1,0,1,0,0,0],
-             [0,1,0,1,0,0],
-             [1,0,1,0,1,0],
-             [0,1,0,1,1,0],
-             [0,0,1,1,1,1],
-             [0,0,0,0,1,1]];
-* * * * * * * * * * * * * * * * * */
+/**
+ * Depth-First Search graph searching algorithm.
+ * Finds out whether there's a path between
+ * two nodes - start node and a target.
+ */
 
 (function (exports) {
-  /**
-   * Depth-first search algorithm for matrix representation of graph.
-   * The algorithm finds whether there's a path between two given nodes.
-   */
-  var depthFirstSearch = (function () {
+  'use strict';
 
-    var visited = [],
-        target,
-        graph;
+  var dfs = (function () {
 
     /**
-     * Returns whether the destination could be reached
-     * from given node
-     *
-     * @private
-     * @param {number} current Current node
-     * @returns {boolean} True/false depending whether
-     *      the destination can be reached from the current node
+     * Implements an iterative DFS.
+     * Complexity O(|V|^2), since it uses adjust matrix.
      */
-    function dfs(current) {
-      if (visited[current] ||
-          current[0] < 0 || current[1] < 0 ||
-          current[0] >= graph.length || current[1] >= graph[0].length ||
-          !graph[current[0]][current[1]]) {
-        return false;
-      }
-      if (current[0] === target[0] &&
-          current[1] === target[1]) {
-        return true;
-      }
+    function hasPath(graph, current, goal) {
+      var stack = [],
+          visited = [],
+          node;
+      stack.push(current);
       visited[current] = true;
-      return dfs([current[0] + 1, current[1]]) ||
-             dfs([current[0] - 1, current[1]]) ||
-             dfs([current[0], current[1] + 1]) ||
-             dfs([current[0], current[1] - 1]);
-    }
-
-    /**
-     * Initializes the algorithm
-     *
-     * @private
-     * @param {array} inputGraph The input matrix of the graph
-     * @param {number} destination The destination
-     */
-    function init(inputGraph, destination) {
-      graph = inputGraph;
-      target = destination;
-      visited = {};
-    }
-
-    /**
-     * Validates the params
-     *
-     * @param {array} graph A matrix representation of the graph
-     * @param {array} source The source node
-     * @param {array} destination The destination node
-     */
-    function validateParams(graph, source, destination) {
-      if (!graph) {
-        throw new Error('The graph should be represented as a matrix');
-      }
-      if (graph[0] === undefined) {
-        throw new Error('The graph should be represented as ' +
-                'a matrix, with size at least 1x1');
-      }
-      var width = graph[0].length;
-      for (var i = 1; i < graph.length; i += 1) {
-        if (graph[i].length !== width) {
-          throw new Error('The graph should be represented as a matrix');
+      while (stack.length) {
+        node = stack.pop();
+        if (node === goal) {
+          return true;
         }
-      }
-      source.concat(destination).filter(function (c, i) {
-        if (c < 0) {
-          throw new Error('The source and destination coordinates ' +
-            'should be above zero');
-        }
-        if (i % 2 === 0) {
-          if (c >= graph.length) {
-            throw new Error('The source and destination coordinates ' +
-                        'should not be above graph\'s size');
-          }
-        } else {
-          if (c >= graph[0].length) {
-            throw new Error('The source and destination coordinates ' +
-                        'should not be above graph\'s size');
+        for (var i = 0; i < graph[node].length; i += 1) {
+          if (graph[node][i] && !visited[i]) {
+            stack.push(i);
+            visited[i] = true;
           }
         }
-      });
-      return true;
+      }
+      return false;
     }
 
     /**
-     * Finds whether there's a path between a given start node
-     * to given destination
+     * Returns whether there's a path between two nodes
+     * in a graph represented with adjust matrix.
      *
      * @public
-     * @param {array} graph A matrix representation of the graph
-     * @param {number} source The source node
-     * @param {number} destination The destination node
-     * @returns {boolean} true/false depending
-     *                               whether there's a path between the nodes
+     * @param {array} graph Adjust matrix representation of a graph
+     * @param {number} start A start node
+     * @param {number} goal The target node
+     * @return {boolean} Returns whether there's a path between start and goal
      */
-    return function (graph, source, destination) {
-      validateParams(graph, source, destination);
-      init(graph, destination);
-      return dfs(source);
+    return function (graph, start, goal) {
+      return hasPath(graph, start, goal);
     };
-
-
   }());
 
-  exports.depthFirstSearch = depthFirstSearch;
+  exports.dfs = dfs;
 
-}(typeof exports === 'undefined' ? window : exports));
+}(typeof exports === 'undefined' ? window : exports));