Added addNode and addEdge feature in adjacency list implementation

Author: linux-nerd

src/graph/adj-list.js

@@ -0,0 +1,43 @@
+import { BST } from '../binary-search-tree/binary-search-tree';
+
+export class AdjacencyList {
+  constructor(isDiGraph) {
+    this.diGraph = isDiGraph;
+    this.edges = new Map();
+  }
+
+  /**
+   * It adds node to the map and assign an empty list
+   * If the node is already added to the map, then nothing happens
+   * @param {any} node
+   */
+  addNode(node) {
+    if (!this.edges.get(node)) {
+      this.edges.set(node, new BST);
+    }
+  }
+
+  /**
+   * It removes the node from the map
+   * @param {any} node
+   */
+  removeNode(node) {
+    this.edges.delete(node);
+  }
+
+  addEdge(fromVertex, toVertex, weight) {
+    if (!this.edges.has(fromVertex)) {
+      this.addNode(fromVertex);
+    }
+
+    if (!this.edges.has(toVertex)) {
+      this.addNode(toVertex);
+    }
+
+    this.edges.get(fromVertex).insert(toVertex, { weight });
+
+    if (!this.diGraph) {
+      this.edges.get(toVertex).insert(fromVertex, { weight });
+    }
+  }
+}

src/graph/adj-list.spec.js

@@ -0,0 +1,88 @@
+import { AdjacencyList } from './adj-list';
+
+describe('Adjacency List', () => {
+  let adjList;
+  beforeEach(() => {
+    adjList = new AdjacencyList();
+  });
+
+  it('should create adjacency list object', () => {
+    expect(adjList).toBeDefined();
+    expect(adjList.edges).toBeDefined();
+  });
+
+  it('should have empty edges when adjacency list object is created', () => {
+    expect(adjList.edges.size).toBe(0);
+  });
+
+  it('should add node through addNode method', () => {
+    expect(adjList.edges.size).toBe(0);
+
+    adjList.addNode('A');
+    expect(adjList.edges.size).toBe(1);
+    expect(adjList.edges.get('A').len).toBe(0);
+
+    adjList.addNode('B');
+    expect(adjList.edges.size).toBe(2);
+    expect(adjList.edges.get('B').len).toBe(0);
+  });
+
+  it('should delete the node from the map', () => {
+    expect(adjList.edges.size).toBe(0);
+
+    adjList.addNode('A');
+    expect(adjList.edges.size).toBe(1);
+
+    adjList.removeNode('A');
+    expect(adjList.edges.size).toBe(0);
+    expect(adjList.edges.has('A')).toBeFalsy();
+  });
+
+  describe('Insert Operation', () => {
+    let unDirectedGraph;
+    beforeEach(() => {
+      unDirectedGraph = new AdjacencyList(false);
+
+      adjList.addNode('A');
+      adjList.addNode('B');
+    });
+
+    it('should add an edge of weight 20 between A and B', () => {
+      adjList.addEdge('A', 'B', 200);
+      const vertexA = adjList.edges.get('A');
+      expect(vertexA.len).toBe(1);
+
+      const lookupB = vertexA.lookup('B');
+      expect(lookupB.hasVal).toBeTruthy();
+      expect(lookupB.currentNode.details.weight).toBe(200);
+    });
+    it('should add edge between B and C', () => {
+      expect(adjList.edges.size).toBe(2);
+
+      adjList.addEdge('B', 'C');
+      expect(adjList.edges.size).toBe(3);
+      const vertexB = adjList.edges.get('B');
+      expect(vertexB.len).toBe(1);
+
+      const lookupC = vertexB.lookup('C');
+      expect(lookupC.hasVal).toBeTruthy();
+      expect(lookupC.currentNode.details.weight).toBe(undefined);
+    });
+    it('should add edge A and B in undirected graph', () => {
+      expect(unDirectedGraph.edges.size).toBe(0);
+
+      unDirectedGraph.addEdge('A', 'B');
+      expect(unDirectedGraph.edges.size).toBe(2);
+
+      const vertexA = unDirectedGraph.edges.get('A');
+      expect(vertexA.len).toBe(1);
+      const lookupB = vertexA.lookup('B');
+      expect(lookupB.hasVal).toBeTruthy();
+
+      const vertexB = unDirectedGraph.edges.get('B');
+      expect(vertexB.len).toBe(1);
+      const lookupA = vertexB.lookup('A');
+      expect(lookupA.hasVal).toBeTruthy();
+    });
+  });
+});

src/graph/graph.js

@@ -0,0 +1,28 @@
+import { AdjacencyList } from './adj-list';
+
+export class Graph {
+  constructor(directed) {
+    this.diGraph = directed === 'directed';
+  }
+  /**
+   * Create a presentation of type adjList and returns the created object
+   * @param {string} presentationType
+   * @returns {AdjacencyList} graph
+   * @example
+   * ```
+   * const graph = new Graph;
+   * const adjList = graph.createGraph('adjList');
+   * ```
+   */
+  createGraph(presentationType) {
+    let graph;
+    if (presentationType === 'adjList') {
+      graph = new AdjacencyList(this.diGraph);
+    } else {
+      return new Error('Graph Type not allowed.');
+    }
+
+    graph.type = presentationType;
+    return graph;
+  }
+}

src/graph/graph.spec.js

@@ -0,0 +1,39 @@
+import { Graph } from './graph';
+
+describe('Graph Factory', () => {
+  it('should create an object of Graph Factory', () => {
+    const graph = new Graph;
+    expect(graph).toBeDefined();
+  });
+
+  describe('Adjacency List', () => {
+    let graph;
+    beforeEach(() => {
+      graph = new Graph('directed');
+    });
+    it('should create adjacency list object', () => {
+      const adjList = graph.createGraph('adjList');
+      expect(adjList).toBeDefined();
+    });
+    it('should have type "adjList"', () => {
+      const adjList = graph.createGraph('adjList');
+      expect(adjList.type).toBeDefined();
+      expect(adjList.type).toBe('adjList');
+    });
+    it('should return error when graph type does not match', () => {
+      const adjList = graph.createGraph('some-error');
+      expect(adjList.message).toBe('Graph Type not allowed.');
+    });
+
+    it('should create a directed graph', () => {
+      const adjList = graph.createGraph('adjList');
+      expect(adjList.diGraph).toBeTruthy();
+    });
+    it('should create a un-directed graph', () => {
+      const graph = new Graph;
+      const adjList = graph.createGraph('adjList');
+      expect(adjList.diGraph).toBeFalsy();
+    });
+  });
+
+});