Merge branch 'master' of https://github.com/Algorithm-archive/Learn-Data_Structure-Algorithm-by-Javascript

Author: minhaz.raufoon

Graph Theory/Breadth First Search/bfs.js

@@ -1,60 +1,89 @@
-function BFSFindShortestPath(graph, srcNode, dstNode) {
-    var isPushed = Object.create(null),
-        bfsQueue,
+/*
+    BFS(Breadth First Search) implementation in JavaScript
+    ------------------------------------------------------
+*/
+
+/**
+ * Processing BFS for the given srcNode in the Graph
+ * @param {Array} graph (will be an adjacency list) 
+ * @param {Number or String} srcNode 
+ * @param {Number or String} dstNode (Optional) 
+ * If the 'dstNode' is not given, then it will process shortest path for all of the nodes from 'srcNode'
+ */
+function BFS(graph, srcNode, dstNode) {
+    var isProcessed = {},
+        bfsQueue = [],
+        parentNodeOf = {},
+        distance = {},
         currentNode,
-        childNode,
-        parentNodeOf = Object.create(null),
-        shortestPath;
-
-    bfsQueue = [srcNode];
-    parentNodeOf[srcNode] = null;
-    isPushed[srcNode] = true;
-
-    while (bfsQueue.length > 0) {
-        currentNode = bfsQueue.shift();
-        if (currentNode === dstNode) break;
-
-        if (!graph[currentNode]) continue;
-        for (var i = 0; i < graph[currentNode].length; i++) {
-            childNode = graph[currentNode][i];
-            if (isPushed[childNode]) continue;
-
-            parentNodeOf[childNode] = currentNode;
-            bfsQueue.push(childNode);
-            isPushed[childNode] = true;
+        childNode;
+
+
+    //Processing the distance and path from the given graph
+    this.init = function() {
+        //Initializing for the 'srcNode'
+        bfsQueue.push(srcNode);
+        parentNodeOf[srcNode] = null;
+        isProcessed[srcNode] = true;
+        distance[srcNode] = 0;
+
+        while (bfsQueue.length > 0) {
+            currentNode = bfsQueue.shift();
+            if (currentNode === dstNode) break;
+
+            var listLength = graph[currentNode].length;
+
+            for (var i = 0; i < listLength; i++) {
+                childNode = graph[currentNode][i];
+                if (isProcessed[childNode]) continue; //already entered in the queue, so don't need to add again
+
+                parentNodeOf[childNode] = currentNode;
+                distance[childNode] = distance[currentNode] + 1;
+                bfsQueue.push(childNode);
+                isProcessed[childNode] = true;
+            }
         }
     }
 
-    if (!isPushed[dstNode]) {
-        return {
-            distance: Infinity,
-            shortestPath: []
+    this.init();
+
+    //Get the shortest distance from the processed 'distance' Array
+    this.getShortestDistance = function (dstNode) {
+        if (!isProcessed[dstNode]) {
+            return Infinity;
+        } else {
+            return distance[dstNode];
         }
     }
 
-    shortestPath = [dstNode];
-    currentNode = dstNode;
+    //Get the Shortest Path from the breadcrumb of the 'parentNodeOf'
+    this.getShortestPath = function(dstNode) {
+        var shortestPath = [dstNode];
+        var currentNode = dstNode;
 
-    while (parentNodeOf[currentNode]) {
-        currentNode = parentNodeOf[currentNode];
-        shortestPath.unshift(currentNode);
-    }
+        if (!isProcessed[dstNode]) return [];
 
-    return {
-        distance: shortestPath.length - 1,
-        shortestPath: shortestPath
+        while (parentNodeOf[currentNode]) {
+            currentNode = parentNodeOf[currentNode];
+            shortestPath.push(currentNode);
+        }
+
+        return shortestPath.reverse();
     }
 }
 
 
-/* TESTING */
+/************ Testing BFS ***************/
 var graph = {
-    1: [2, 3],
-    2: [1, 3, 4, 5],
+    0: [1, 2],
+    1: [0, 2, 3, 4],
+    2: [0, 1, 3],
     3: [1, 2, 4],
-    4: [2, 3, 5],
-    5: [2, 4],
+    4: [1, 3],
 }
-var srcNode = 1, destNode = 5;
+var srcNode = 1, dstNode = 4;
+
+var bfs = new BFS(graph, srcNode);
 
-console.log(BFSFindShortestPath(graph, srcNode, destNode));
+console.log(bfs.getShortestDistance(dstNode));
+console.log(bfs.getShortestPath(dstNode).join(' -> '));

Graph Theory/Graph Representation/adj-matrix-graph.js

@@ -138,7 +138,7 @@ function Graph(V) {
 }
 
 
-/************ Graph Representation ***************/
+/************ Testing Graph Representation ***************/
 
 //Initializing a new Graph Object by giving it's size as a parameter
 var graph = new Graph(5);

README.md

@@ -39,7 +39,7 @@
   - [Radix Sort](./Sorting/Radix%20Sort/)
 
 
-- Graph Algorithms
+- [Graph Algorithms](./Graph%20Algorithms)
     - [Graph Representation](./Graph%20Theory/Graph%20Representation)
     - [Breadth First Search (BFS)](./Graph%20Theory/Breadth%20First%20Search)
     - [Depth First Search (DFS)](./Graph%20Theory/Depth%20First%20Search)