add graph breadth first traversal method

Author: whbrown

dist/datastructures/Graph.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const Stack_1 = __importDefault(require("./Stack"));
+const Queue_1 = __importDefault(require("./Queue"));
 ;
 ;
 ;
@@ -100,6 +101,28 @@ class Graph {
             }
             return results;
         };
+        this.breathFirstTraversal = (startingVertex, map = v => v) => {
+            let results = [];
+            if (!startingVertex)
+                return null;
+            const queue = new Queue_1.default();
+            const visited = { [startingVertex]: true };
+            queue.enqueue(startingVertex);
+            let dequeuedNode;
+            while (queue.length) {
+                dequeuedNode = queue.dequeue();
+                if (dequeuedNode) {
+                    results.push(map(dequeuedNode.data));
+                    for (let neighbour of this.adjacencyList[dequeuedNode.data]) {
+                        if (!visited[neighbour]) {
+                            visited[neighbour] = true;
+                            queue.enqueue(neighbour);
+                        }
+                    }
+                }
+            }
+            return results;
+        };
         this.adjacencyList = {};
         // TODO: change directional to boolean and have it be set in constructor
     }

dist/datastructures/Graph.test.js

@@ -83,10 +83,10 @@ describe('basic graph functionality', () => {
     });
 });
 describe('depth first traversal of graphs', () => {
-    test('dfs method exists', () => {
+    test('DFS method exists', () => {
         expect(typeof graph.depthFirstTraversal).toBe('function');
     });
-    test('dfs method returns array of all connected vertices', () => {
+    test('DFS method returns array of all connected vertices', () => {
         populateGraph(graph);
         let results = graph.depthFirstTraversal('Alice');
         expect(results).toEqual(["Alice", "Cheshire Cat", "Mad Hatter", "March Hare", "Dormouse", "Time"]);
@@ -95,7 +95,7 @@ describe('depth first traversal of graphs', () => {
     });
 });
 describe('iterative implementation of DFS', () => {
-    test('iterative dfs method exists', () => {
+    test('iterative DFS method exists', () => {
         expect(typeof graph.iterativeDFS).toBe('function');
     });
     test('iterative dfs method returns array of all connected vertices in proper order', () => {
@@ -106,3 +106,19 @@ describe('iterative implementation of DFS', () => {
         expect(results).toEqual(["Time", "Mad Hatter", "Dormouse", "March Hare", "Alice", "Cheshire Cat"]);
     });
 });
+describe('breadth first search implementation', () => {
+    test('BFS method exists', () => {
+        expect(typeof graph.breathFirstTraversal).toBe('function');
+    });
+    test('breath first search returns array of all connected vertices in proper order', () => {
+        populateGraph(graph);
+        let results = graph.breathFirstTraversal('Alice');
+        expect(results).toEqual(['Alice', 'Cheshire Cat', 'Mad Hatter',
+            'March Hare', 'Dormouse', 'Time']);
+        // n.b. time comes last as it has a distance of 2
+        results = graph.breathFirstTraversal('Time');
+        expect(results).toEqual(['Time', 'Mad Hatter', 'Alice', 'March Hare',
+            'Dormouse', 'Cheshire Cat']);
+        // n.b. cheshire cat comes last as it has a distance of 2
+    });
+});

src/datastructures/Graph.test.ts

@@ -84,10 +84,10 @@ describe('basic graph functionality', () => {
 });
 
 describe('depth first traversal of graphs', () => {
-  test('dfs method exists', () => {
+  test('DFS method exists', () => {
     expect(typeof graph.depthFirstTraversal).toBe('function');
   });
-  test('dfs method returns array of all connected vertices', () => {
+  test('DFS method returns array of all connected vertices', () => {
     populateGraph(graph);
     let results = graph.depthFirstTraversal('Alice');
     expect(results).toEqual(["Alice", "Cheshire Cat", "Mad Hatter", "March Hare", "Dormouse", "Time"]);
@@ -97,7 +97,7 @@ describe('depth first traversal of graphs', () => {
 });
 
 describe('iterative implementation of DFS', () => {
-  test('iterative dfs method exists', () => {
+  test('iterative DFS method exists', () => {
     expect(typeof graph.iterativeDFS).toBe('function')
   });
   test('iterative dfs method returns array of all connected vertices in proper order', () => {
@@ -107,4 +107,21 @@ describe('iterative implementation of DFS', () => {
     results = graph.iterativeDFS('Time'); // different route
     expect(results).toEqual(["Time", "Mad Hatter", "Dormouse", "March Hare", "Alice", "Cheshire Cat"]);
   });
-})
+});
+
+describe('breadth first search implementation', () => {
+  test('BFS method exists', () => {
+    expect(typeof graph.breathFirstTraversal).toBe('function')
+  });
+  test('breath first search returns array of all connected vertices in proper order', () => {
+    populateGraph(graph);
+    let results = graph.breathFirstTraversal('Alice');
+    expect(results).toEqual(['Alice', 'Cheshire Cat', 'Mad Hatter',
+      'March Hare', 'Dormouse', 'Time']);
+    // n.b. time comes last as it has a distance of 2
+    results = graph.breathFirstTraversal('Time');
+    expect(results).toEqual(['Time', 'Mad Hatter', 'Alice', 'March Hare',
+      'Dormouse', 'Cheshire Cat']);
+    // n.b. cheshire cat comes last as it has a distance of 2
+  });
+});

src/datastructures/Graph.ts

@@ -1,4 +1,5 @@
 import Stack from './Stack';
+import Queue from './Queue';
 import _Node from './Node';
 
 type vertex = string;
@@ -89,7 +90,7 @@ class Graph {
     }
     helper(vertex);
     return results;
-  }
+  };
 
   iterativeDFS = (startingVertex: vertex, map: (vertex: vertex) => unknown = v => v): unknown[] => {
     let stack = new Stack<string>();
@@ -111,6 +112,28 @@ class Graph {
       }
     }
     return results;
-  }
+  };
+
+  breathFirstTraversal = (startingVertex: vertex, map: (vertex: vertex) => unknown = v => v): unknown[] | null => {
+    let results: unknown[] = [];
+    if (!startingVertex) return null;
+    const queue = new Queue<vertex>()
+    const visited: { [vertex: string]: boolean } = { [startingVertex]: true };
+    queue.enqueue(startingVertex);
+    let dequeuedNode;
+    while (queue.length) {
+      dequeuedNode = queue.dequeue();
+      if (dequeuedNode) {
+        results.push(map(dequeuedNode.data));
+        for (let neighbour of this.adjacencyList[dequeuedNode.data]) {
+          if (!visited[neighbour]) {
+            visited[neighbour] = true;
+            queue.enqueue(neighbour);
+          }
+        }
+      }
+    }
+    return results;
+  };
 }
 export default Graph;