refactor

Author: amejiarosario

lib/data-structures/graphs/graph.js

@@ -31,6 +31,9 @@ class Graph {
   /**
    * Add a node to the graph.
    * Returns the new node or the existing one if it already exits.
+   *
+   * Runtime: O(1)
+   *
    * @param {any} value node's value
    */
   addVertex(value) {
@@ -45,6 +48,9 @@ class Graph {
 
   /**
    * Removes node from graph
+   *
+   * Runtime: O(|V| + |E|)
+   *
    * @param {any} value node's value
    */
   removeVertex(value) {
@@ -58,44 +64,66 @@ class Graph {
   }
 
   /**
-   * Create a connection between source node and target node.
-   * If the graph is undirected it will also create the conneciton from target to destination.
+   * Create a connection between source node and destination node.
+   * If the graph is undirected it will also create the conneciton from destination to destination.
    * If the nodes doesn't exist then it will create them on the fly
+   *
+   * Runtime: O(1)
+   *
    * @param {any} source
-   * @param {any} target
+   * @param {any} destination
    */
-  addEdge(source, target) {
+  addEdge(source, destination) {
     const sourceNode = this.addVertex(source);
-    const targetNode = this.addVertex(target);
+    const destinationNode = this.addVertex(destination);
 
-    sourceNode.addAdjacent(targetNode);
+    sourceNode.addAdjacent(destinationNode);
 
     if(this.edgeDirection === Graph.UNDIRECTED) {
-      targetNode.addAdjacent(sourceNode);
+      destinationNode.addAdjacent(sourceNode);
     }
 
-    return [sourceNode, targetNode];
+    return [sourceNode, destinationNode];
   }
 
   /**
-   * Remove connection between source node and target.
-   * If the graph is undirected it will also remove the conneciton from target to destination.
+   * Remove connection between source node and destination.
+   * If the graph is undirected it will also remove the conneciton from destination to destination.
+   *
+   * Runtime: O(|E|)
+   *
    * @param {any} source
-   * @param {any} target
+   * @param {any} destination
    */
-  removeEdge(source, target) {
+  removeEdge(source, destination) {
     const sourceNode = this.nodes.get(source);
-    const targetNode = this.nodes.get(target);
+    const destinationNode = this.nodes.get(destination);
 
-    if(sourceNode && targetNode) {
-      sourceNode.removeAdjacent(targetNode);
+    if(sourceNode && destinationNode) {
+      sourceNode.removeAdjacent(destinationNode);
 
       if(this.edgeDirection === Graph.UNDIRECTED) {
-        targetNode.removeAdjacent(sourceNode);
+        destinationNode.removeAdjacent(sourceNode);
       }
     }
 
-    return [sourceNode, targetNode];
+    return [sourceNode, destinationNode];
+  }
+
+  /**
+   * True if two nodes are adjacent to each other
+   * @param {any} source node's value
+   * @param {any} destination node's value
+   */
+  areAdjacents(source, destination) {
+    const sourceNode = this.nodes.get(source);
+    const destinationNode = this.nodes.get(destination);
+
+    if(sourceNode && destinationNode) {
+      return sourceNode.isAdjacent(destinationNode);
+    }
+
+    return false;
   }
 
   /**

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

@@ -96,6 +96,34 @@ describe('Graph', () => {
     });
   });
 
+  describe('#areAdjacents', () => {
+    it('should return true if nodes are adjacent', () => {
+      graph.addEdge('a', 'b');
+      expect(graph.areAdjacents('a', 'b')).toBe(true);
+    });
+
+    it('should return false if a digraph nodes are adjacent in one direction only', () => {
+      graph.addEdge('a', 'b');
+      expect(graph.areAdjacents('b', 'a')).toBe(false);
+    });
+
+    it('should return true if a undirected graph nodes are adjacent', () => {
+      graph = new Graph(Graph.UNDIRECTED);
+      graph.addEdge('a', 'b');
+      expect(graph.areAdjacents('b', 'a')).toBe(true);
+    });
+
+    it('should return false if nodes does not exist', () => {
+      expect(graph.areAdjacents('a', 'b')).toBe(false);
+    });
+
+    it('should return false if nodes are not adjacent', () => {
+      graph.addVertex('a');
+      graph.addVertex('b');
+      expect(graph.areAdjacents('a', 'b')).toBe(false);
+    });
+  });
+
   describe('remove vertex and update adjacency list', () => {
     let n1, n2, n4;
 
@@ -150,6 +178,7 @@ describe('Graph', () => {
     });
   });
 
+
   function getValue(node) {
     return node.value;
   }

lib/data-structures/graphs/node.js

@@ -9,6 +9,9 @@ class Node {
 
   /**
    * Add node to adjacency list
+   *
+   * Runtime: O(1)
+   *
    * @param {Node} node
    */
   addAdjacent(node) {
@@ -17,6 +20,9 @@ class Node {
 
   /**
    * Remove node from adjacency list
+   *
+   * Runtime: O(n)
+   *
    * @param {Node} node
    */
   removeAdjacent(node) {
@@ -27,6 +33,17 @@ class Node {
     }
   }
 
+  /**
+   * Check if a Node is adjacent to other
+   *
+   * Runtime: O(n)
+   *
+   * @param {Node} node
+   */
+  isAdjacent(node) {
+    return this.adjacents.indexOf(node) > -1;
+  }
+
   /**
    * Get all adjacent nodes
    */

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

@@ -51,4 +51,17 @@ describe('Node (Graph)', () => {
       expect(node.getAdjacents().map(n => n.value)).toEqual([])
     });
   });
+
+  describe('#isAdjacent', () => {
+    it('should return true if they are adjacent', () => {
+      const b = new Node('b');
+      node.addAdjacent(b);
+      expect(node.isAdjacent(b)).toBe(true);
+    });
+
+    it('should return true if they are adjacent', () => {
+      const c = new Node('c');
+      expect(node.isAdjacent(c)).toBe(false);
+    });
+  });
 });