feat: implements breadth-first search on a graph

Author: thawkin3

src/data-structures/directed-graph/src/directed-graph.js

@@ -61,9 +61,38 @@ export class DirectedGraph {
     console.log(printedMessage)
   }
 
-  // eslint-disable-next-line no-unused-vars
-  breadthFirstSearch(startingNode, searchingForNode) {}
+  breadthFirstSearch(startingNode, searchingForNode, callback) {
+    const visitedNodes = {}
+    const nodesToVisitQueue = []
+
+    nodesToVisitQueue.push(startingNode)
+
+    while (nodesToVisitQueue.length > 0) {
+      const currentNode = nodesToVisitQueue.shift()
+
+      if (!visitedNodes[currentNode]) {
+        visitedNodes[currentNode] = true
+        callback(currentNode)
+
+        if (currentNode === searchingForNode) {
+          break
+        }
+
+        const currentNodeNeighbors = this.nodes.get(currentNode)
+        console.log(
+          'currentNode:',
+          currentNode,
+          'currentNodeNeighbors:',
+          currentNodeNeighbors.join(', ')
+        )
+
+        currentNodeNeighbors.forEach(neighborNode => {
+          nodesToVisitQueue.push(neighborNode)
+        })
+      }
+    }
+  }
 
   // eslint-disable-next-line no-unused-vars
-  depthFirstSearch(startingNode, searchingForNode) {}
+  depthFirstSearch(startingNode, searchingForNode, callback) {}
 }

src/data-structures/directed-graph/src/directed-graph.test.js

@@ -122,7 +122,126 @@ D ->
     })
   })
 
-  describe('breadthFirstSearch', () => {})
+  describe('breadthFirstSearch', () => {
+    it('performs a breadth-first search starting at a given node in a non-tree-like graph', () => {
+      // A  ->  B
+      // |    / |
+      // v  <   v
+      // C  ->  D
+      const graph = new DirectedGraph()
+
+      graph.addNode('A')
+      graph.addNode('B')
+      graph.addNode('C')
+      graph.addNode('D')
+
+      graph.addEdge('A', 'B')
+      graph.addEdge('A', 'C')
+      graph.addEdge('B', 'C')
+      graph.addEdge('B', 'D')
+      graph.addEdge('C', 'D')
+
+      const visitedNodes = []
+      const traversalCallback = node => {
+        visitedNodes.push(node)
+      }
+
+      graph.breadthFirstSearch('A', 'D', traversalCallback)
+
+      expect(visitedNodes).toEqual(['A', 'B', 'C', 'D'])
+    })
+
+    it('performs a breadth-first search starting at a given node at the top of a tree and ending at the bottom right of the tree', () => {
+      //                A
+      //    B           C           D
+      // E     F     G     H     I     J
+      const graph = new DirectedGraph()
+
+      graph.addNode('A')
+      graph.addNode('B')
+      graph.addNode('C')
+      graph.addNode('D')
+      graph.addNode('E')
+      graph.addNode('F')
+      graph.addNode('G')
+      graph.addNode('H')
+      graph.addNode('I')
+      graph.addNode('J')
+
+      graph.addEdge('A', 'B')
+      graph.addEdge('A', 'C')
+      graph.addEdge('A', 'D')
+
+      graph.addEdge('B', 'E')
+      graph.addEdge('B', 'F')
+
+      graph.addEdge('C', 'G')
+      graph.addEdge('C', 'H')
+
+      graph.addEdge('D', 'I')
+      graph.addEdge('D', 'J')
+
+      const visitedNodes = []
+      const traversalCallback = node => {
+        visitedNodes.push(node)
+      }
+
+      graph.breadthFirstSearch('A', 'J', traversalCallback)
+
+      expect(visitedNodes).toEqual([
+        'A',
+        'B',
+        'C',
+        'D',
+        'E',
+        'F',
+        'G',
+        'H',
+        'I',
+        'J',
+      ])
+    })
+
+    it('performs a breadth-first search starting at a given node at the top of a tree and ending midway through the tree without visiting every node', () => {
+      //                A
+      //    B           C           D
+      // E     F     G     H     I     J
+      const graph = new DirectedGraph()
+
+      graph.addNode('A')
+      graph.addNode('B')
+      graph.addNode('C')
+      graph.addNode('D')
+      graph.addNode('E')
+      graph.addNode('F')
+      graph.addNode('G')
+      graph.addNode('H')
+      graph.addNode('I')
+      graph.addNode('J')
+
+      graph.addEdge('A', 'B')
+      graph.addEdge('A', 'C')
+      graph.addEdge('A', 'D')
+
+      graph.addEdge('B', 'E')
+      graph.addEdge('B', 'F')
+
+      graph.addEdge('C', 'G')
+      graph.addEdge('C', 'H')
+
+      graph.addEdge('D', 'I')
+      graph.addEdge('D', 'J')
+
+      const visitedNodes = []
+      const traversalCallback = node => {
+        visitedNodes.push(node)
+      }
+
+      graph.breadthFirstSearch('A', 'F', traversalCallback)
+
+      expect(visitedNodes).toEqual(['A', 'B', 'C', 'D', 'E', 'F'])
+    })
+  })
 
   describe('depthFirstSearch', () => {})
 })