feat(graph) are connected and find path

Author: amejiarosario

lib/data-structures/graphs/graph.js

@@ -145,8 +145,8 @@ class Graph {
   }
 
   /**
-   *
-   * @param {Node} first
+   * Generic graph search where we can pass a Stack or Queue
+   * @param {Node} first node to start the search
    * @param {Stack|Queue} dsType Stack for DFS or Queue for BFS
    */
   *_graphSearch(first, dsType = Stack) {
@@ -164,6 +164,59 @@ class Graph {
       }
     }
   }
+
+  /**
+   * Return true if two nodes are connected and false if not
+   * @param {any} source vertex's value
+   * @param {*} destination vertex's value
+   */
+  areConnected(source, destination) {
+    const sourceNode = this.nodes.get(source);
+    const destinationNode = this.nodes.get(destination);
+
+    if(sourceNode && destinationNode) {
+      const bfsFromFirst = this.bfs(sourceNode);
+      for (const node of bfsFromFirst) {
+        if(node === destinationNode) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Find a path between source and destination
+   * It might not be the optimal path
+   *
+   * @param {any} source vertex's value
+   * @param {any} destination vertex's value
+   * @param {Map<Node>} path current path from source to destination
+   * @returns list of nodes from source to destination
+   */
+  findPath(source, destination, path = new Map()) {
+    const sourceNode = this.nodes.get(source);
+    const destinationNode = this.nodes.get(destination);
+
+    path.set(sourceNode);
+
+    for (const node of sourceNode.getAdjacents()) {
+      if(node === destinationNode) {
+        path.set(destinationNode);
+        return Array.from(path.keys());
+      }
+
+      if(!path.has(node)) {
+        const newPath = this.findPath(node.value, destination, path);
+        if(newPath.length) {
+          return newPath;
+        }
+      }
+    }
+
+    return [];
+  }
 }
 
 Graph.UNDIRECTED = Symbol('directed graph'); // one-way edges

lib/data-structures/graphs/graph.spec.js

@@ -178,6 +178,97 @@ describe('Graph', () => {
     });
   });
 
+  describe('Graph Search: UNDIRECTED', () => {
+    let first;
+
+    beforeEach(() => {
+      graph = new Graph(Graph.UNDIRECTED);
+      [first] = graph.addEdge(1, 2);
+      graph.addEdge(1, 3);
+      graph.addEdge(1, 4);
+
+      graph.addEdge(5, 2);
+      graph.addEdge(6, 3);
+      graph.addEdge(7, 3);
+      graph.addEdge(8, 4);
+      graph.addEdge(9, 5);
+      graph.addEdge(10, 6);
+    });
+
+    describe('#dfs', () => {
+
+      it('should visit nodes using depth-first search', () => {
+        const visitedOrder = Array.from(graph.dfs(first)).map(getValue);
+        expect(visitedOrder).toEqual([1, 4, 8, 3, 7, 6, 10, 2, 5, 9]);
+      });
+
+      it('should use iterator', () => {
+        const dfs = graph.dfs(first);
+
+        expect(dfs.next().value.value).toBe(1);
+        expect(dfs.next().value.value).toBe(4);
+        expect(dfs.next().value.value).toBe(8);
+        expect(dfs.next().value.value).toBe(3);
+        expect(dfs.next().value.value).toBe(7);
+        expect(dfs.next().value.value).toBe(6);
+        expect(dfs.next().value.value).toBe(10);
+        expect(dfs.next().value.value).toBe(2);
+        expect(dfs.next().value.value).toBe(5);
+        expect(dfs.next().value.value).toBe(9);
+
+        expect(dfs.next().value).toBe(undefined);
+        expect(dfs.next().done).toBe(true);
+      });
+    });
+
+    describe('#bfs', () => {
+
+      it('should visit nodes using breadth-first search', () => {
+        const visitedOrder = Array.from(graph.bfs(first)).map(getValue);
+        expect(visitedOrder).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+      });
+    });
+  });
+
+  describe('with (people) edges on undigraph', () => {
+    let you, mary, barbara;
+
+    beforeEach(() => {
+      graph = new Graph(Graph.UNDIRECTED);
+      [you] = graph.addEdge('You', 'Mary');
+      [mary, barbara] = graph.addEdge('Mary', 'Barbara');
+    });
+
+    describe('#areConnected', () => {
+
+      it('should return true if two nodes are connected', () => {
+        expect(graph.areConnected('You', 'Barbara')).toBe(true);
+      });
+
+      it('should return true if two nodes are connected', () => {
+        expect(graph.areConnected('You', 'You')).toBe(true);
+      });
+
+      it('should return true if two nodes are connected', () => {
+        expect(graph.areConnected('You', 'John')).toBe(false);
+      });
+    });
+
+    describe('#findPath', () => {
+      it('should get connecting path', () => {
+        expect(graph.findPath('You', 'Barbara').map(getValue)).toEqual(['You', 'Mary', 'Barbara']);
+      });
+
+      it('should get adjacent connecting path', () => {
+        expect(graph.findPath('Mary', 'Barbara').map(getValue)).toEqual(['Mary', 'You', 'Barbara']);
+      });
+
+      it('should return empty if there is no connection', () => {
+        expect(graph.findPath('You', 'Obama').map(getValue)).toEqual([]);
+      });
+    });
+  });
+
 
   function getValue(node) {
     return node.value;