handles remove case for graph

Author: amejiarosario

lib/data-structures/graphs/graph.js

@@ -48,6 +48,12 @@ class Graph {
    * @param {any} value node's value
    */
   removeVertex(value) {
+    const current = this.nodes.get(value);
+    if(current) {
+      for (const node of this.nodes.values()) {
+        node.removeAdjacent(current);
+      }
+    }
     return this.nodes.delete(value);
   }
 

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

@@ -42,18 +42,18 @@ describe('Graph', () => {
 
     it('should add node a as adjacent of b', () => {
       const [a, b] = graph.addEdge('a', 'b');
-      expect(a.adjacents.map(n => n.value)).toEqual(['b']);
-      expect(b.adjacents.map(n => n.value)).toEqual([]);
+      expect(a.adjacents.map(getValue)).toEqual(['b']);
+      expect(b.adjacents.map(getValue)).toEqual([]);
 
       graph.addEdge('b', 'a');
-      expect(b.adjacents.map(n => n.value)).toEqual(['a']);
+      expect(b.adjacents.map(getValue)).toEqual(['a']);
     });
 
     it('should add both connection on undirected graph', () => {
       graph = new Graph(Graph.UNDIRECTED);
       const [a, b] = graph.addEdge('a', 'b');
-      expect(a.adjacents.map(n => n.value)).toEqual(['b']);
-      expect(b.adjacents.map(n => n.value)).toEqual(['a']);
+      expect(a.adjacents.map(getValue)).toEqual(['b']);
+      expect(b.adjacents.map(getValue)).toEqual(['a']);
     });
 
     it('should add falsy values', () => {
@@ -70,21 +70,21 @@ describe('Graph', () => {
 
     it('should remove edges if they exist', () => {
       const [a, b] = graph.removeEdge('a', 'b');
-      expect(a.adjacents.map(n => n.value)).toEqual([]);
-      expect(b.adjacents.map(n => n.value)).toEqual([]);
+      expect(a.adjacents.map(getValue)).toEqual([]);
+      expect(b.adjacents.map(getValue)).toEqual([]);
     });
 
     it('should remove edges with falsy values', () => {
       const [a, b] = graph.addEdge(0, false);
-      expect(a.adjacents.map(n => n.value)).toEqual([false]);
+      expect(a.adjacents.map(getValue)).toEqual([false]);
       graph.removeEdge(0, false);
-      expect(a.adjacents.map(n => n.value)).toEqual([]);
+      expect(a.adjacents.map(getValue)).toEqual([]);
     });
 
     it('should not create node when removing unexisting target', () => {
       const [a, c] = graph.removeEdge('a', 'c');
       expect(graph.nodes.size).toBe(2);
-      expect(a.adjacents.map(n => n.value)).toEqual(['b']);
+      expect(a.adjacents.map(getValue)).toEqual(['b']);
       expect(c).toBe(undefined);
     });
 
@@ -96,6 +96,26 @@ describe('Graph', () => {
     });
   });
 
+  describe('remove vertex and update adjacency list', () => {
+    let n1, n2, n4;
+
+    beforeEach(() => {
+      // 0 -> 1 <- 2
+      //      ^\-> 4 -> 3
+      graph.addEdge(0, 1);
+      [n2] = graph.addEdge(2, 1);
+      [n1, n4] = graph.addEdge(1, 4);
+      graph.addEdge(4, 1);
+      graph.addEdge(4, 3);
+    });
+
+    it('should remove nodes from adjacent list', () => {
+      expect(n4.getAdjacents().map(getValue)).toEqual([1, 3]);
+      graph.removeVertex(1);
+      expect(n4.getAdjacents().map(getValue)).toEqual([3]);
+    });
+  });
+
   describe('Graph Search', () => {
     let first;
 
@@ -116,19 +136,21 @@ describe('Graph', () => {
     describe('#dfs', () => {
 
       it('should visit nodes using depth-first search', () => {
-        const visitedOrder = Array.from(graph.dfs(first)).map(v => v.value);
+        const visitedOrder = Array.from(graph.dfs(first)).map(getValue);
         expect(visitedOrder).toEqual([0, 1, 3, 2, 4, 5]);
       });
     });
 
     describe('#bfs', () => {
 
       it('should visit nodes using breadth-first search', () => {
-        const visitedOrder = Array.from(graph.bfs(first)).map(v => v.value);
+        const visitedOrder = Array.from(graph.bfs(first)).map(getValue);
         expect(visitedOrder).toEqual([0, 5, 4, 1, 3, 2]);
       });
     });
   });
 
-
+  function getValue(node) {
+    return node.value;
+  }
 });

lib/exercises/easy/two-sum/two-sum.js

@@ -0,0 +1,27 @@
+/**
+ * Given an array of integers, return indices of the two numbers such that they add up to a specific target.
+ *
+ * You may assume that each input would have exactly one solution, and you may not use the same element twice.
+ *
+ * @example twoSum([2, 7, 11, 15], 9) === [0, 1]
+ *
+ * @param {Number[]} nums
+ * @param {Number} target
+ * @returns {Number[]}
+ */
+function twoSum(nums, target) {
+  const map = new Map();
+
+  for (let index = 0; index < nums.length; index++) {
+    const number = nums[index];
+    const complement = target - number;
+
+    if(map.has(complement) && index !== map.get(complement)) {
+      return [map.get(complement), index];
+    }
+
+    map.set(number, index);
+  }
+}
+
+module.exports = twoSum;

lib/exercises/easy/two-sum/two-sum.spec.js

@@ -0,0 +1,19 @@
+const twoSum = require('./two-sum');
+
+describe('Two Sum', () => {
+  it('should find indices', () => {
+    expect(twoSum([2, 7, 11, 15], 9)).toEqual([0, 1]);
+  });
+
+  it('should return undefined if there is no found', () => {
+    expect(twoSum([2, 7, 11, 15], 10)).toBe(undefined);
+  });
+
+  it('should not use the same element twice', () => {
+    expect(twoSum([3, 2, 4], 6)).toEqual([1, 2]);
+  });
+
+  it('should work with the same number if different indices', () => {
+    expect(twoSum([3, 3], 6)).toEqual([0, 1]);
+  });
+});