Merge pull request #1 from TheAlgorithms/master

update fork

DIRECTORY.md

@@ -74,6 +74,8 @@
   * [ZeroOneKnapsack](https://github.com/TheAlgorithms/Javascript/blob/master/Dynamic-Programming/ZeroOneKnapsack.js)
 
 ## Graphs
+  * [BreadthFirstSearch](https://github.com/TheAlgorithms/Javascript/blob/master/Graphs/BreadthFirstSearch.js)
+  * [BreadthFirstShortestPath](https://github.com/TheAlgorithms/Javascript/blob/master/Graphs/BreadthFirstShortestPath.js)
   * [ConnectedComponents](https://github.com/TheAlgorithms/Javascript/blob/master/Graphs/ConnectedComponents.js)
   * [Density](https://github.com/TheAlgorithms/Javascript/blob/master/Graphs/Density.js)
   * [DepthFirstSearchIterative](https://github.com/TheAlgorithms/Javascript/blob/master/Graphs/DepthFirstSearchIterative.js)

Graphs/BreadthFirstSearch.js

@@ -0,0 +1,64 @@
+/*
+Breadth-first search is an algorithm for traversing a graph. It's discovers all nodes reachable from the starting position by exploring all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level.
+(description adapted from https://en.wikipedia.org/wiki/Breadth-first_search )
+(see also: https://www.koderdojo.com/blog/breadth-first-search-and-shortest-path-in-csharp-and-net-core )
+*/
+
+/*
+Doctests
+> Array.from(breadthFirstSearch(graph, "C"))
+[ 'C', 'D', 'A', 'B', 'E' ]
+> Array.from(breadthFirstSearch(graph, "A"))
+[ 'A', 'B', 'D', 'E' ]
+> Array.from(breadthFirstSearch(graph, "F"))
+[ 'F', 'G' ]
+*/
+
+function breadthFirstSearch (graph, startingNode) {
+  // visited keeps track of all nodes visited
+  const visited = new Set()
+
+  // queue contains the nodes to be explored in the future
+  const queue = [startingNode]
+
+  while (queue.length > 0) {
+    // start with the queue's first node
+    const node = queue.shift()
+
+    if (!visited.has(node)) {
+      // mark the node as visited
+      visited.add(node)
+      const neighbors = graph[node]
+
+      // put all its neighbors into the queue
+      for (let i = 0; i < neighbors.length; i++) {
+        queue.push(neighbors[i])
+      }
+    }
+  }
+
+  return visited
+}
+
+const graph = {
+  A: ['B', 'D'],
+  B: ['E'],
+  C: ['D'],
+  D: ['A'],
+  E: ['D'],
+  F: ['G'],
+  G: []
+}
+/*
+      A <-> B
+      ʌ     |
+      |     |
+      v     v
+C --> D <-- E
+
+F --> G
+*/
+
+console.log(breadthFirstSearch(graph, 'C'))
+console.log(breadthFirstSearch(graph, 'A'))
+console.log(breadthFirstSearch(graph, 'F'))

Graphs/BreadthFirstShortestPath.js

@@ -0,0 +1,88 @@
+/*
+Breadth-first approach can be applied to determine the shortest path between two nodes
+in an equi-weighted graph. It searches the target node among all neighbors of the
+starting node, then the process is repeated on the level of the neighbors of the
+neighbors and so on.
+(See also: https://en.wikipedia.org/wiki/Breadth-first_search )
+(see also: https://www.koderdojo.com/blog/breadth-first-search-and-shortest-path-in-csharp-and-net-core )
+*/
+
+/*
+Doctests
+> breadthFirstShortestPath(graph, 'C', 'E')
+[ 'C', 'D', 'A', 'B', 'E' ]
+> breadthFirstShortestPath(graph, 'E', 'B')
+[ 'E', 'D', 'A', 'B' ]
+> breadthFirstShortestPath(graph, 'F', 'G')
+[ 'F', 'G' ]
+> breadthFirstShortestPath(graph, 'A', 'G')
+[]
+*/
+
+function breadthFirstShortestPath (graph, startNode, targetNode) {
+  // check if startNode & targetNode are identical
+  if (startNode === targetNode) {
+    return [startNode]
+  }
+
+  // visited keeps track of all nodes visited
+  const visited = new Set()
+
+  // queue contains the paths to be explored in the future
+  const initialPath = [startNode]
+  const queue = [initialPath]
+
+  while (queue.length > 0) {
+    // start with the queue's first path
+    const path = queue.shift()
+    const node = path[path.length - 1]
+
+    // explore this node if it hasn't been visited yet
+    if (!visited.has(node)) {
+      // mark the node as visited
+      visited.add(node)
+
+      const neighbors = graph[node]
+
+      // create a new path in the queue for each neighbor
+      for (let i = 0; i < neighbors.length; i++) {
+        const newPath = path.concat([neighbors[i]])
+
+        // the first path to contain the target node is the shortest path
+        if (neighbors[i] === targetNode) {
+          return newPath
+        }
+
+        // queue the new path
+        queue.push(newPath)
+      }
+    }
+  }
+
+  // the target node was not reachable
+  return []
+}
+
+const graph = {
+  A: ['B', 'D'],
+  B: ['E'],
+  C: ['D'],
+  D: ['A'],
+  E: ['D'],
+  F: ['G'],
+  G: []
+}
+/*
+      A <-> B
+      ʌ     |
+      |     |
+      v     v
+C --> D <-- E
+
+F --> G
+*/
+
+console.log(breadthFirstShortestPath(graph, 'C', 'E'))
+console.log(breadthFirstShortestPath(graph, 'E', 'B'))
+console.log(breadthFirstShortestPath(graph, 'F', 'G'))
+console.log(breadthFirstShortestPath(graph, 'A', 'G'))