Add the Bellman-Ford algorithm

Author: FSou1

src/algorithms/graph/bellman-ford/README.md

@@ -0,0 +1,24 @@
+# Bellman-Ford
+
+## Applications
+
+Same as the others algorithms (e.g. Dijkstra) for finding the shortest path:
+
+* Searching for a shortest path
+* Build an optimal path at geographical maps
+* Network routing protocols
+
+Moreover, due to its ability to work with negative edges, the algorithm is also used for:
+
+* Finding negative cycles
+
+## Complexity
+
+**Time Complexity**: `O(|V| * |E|)` since the algorithm performs one outer (over vertices) and one inner (over edges) loop.
+
+**Space Complexity**: `O(|V|)` since the algorithm persists two dictionaries of length `|V|`.
+
+## References
+
+- [Youtube](https://www.youtube.com/watch?v=ozsuci5pIso);
+- [Wikipedia](https://en.wikipedia.org/wiki/Bellman%E2%80%93Ford_algorithm);

src/algorithms/graph/bellman-ford/__tests__/bellmanFord.test.ts

@@ -0,0 +1,88 @@
+import {GraphVertex} from '../../../../data-structures/graph/graphVertex';
+import {GraphEdge} from '../../../../data-structures/graph/graphEdge';
+import {Graph} from '../../../../data-structures/graph/graph';
+import {bellmanFord} from '../bellmanFord';
+
+test('should return shortest path to vertices', () => {
+  const vertexA = new GraphVertex('A');
+  const vertexB = new GraphVertex('B');
+  const vertexC = new GraphVertex('C');
+  const vertexD = new GraphVertex('D');
+  const vertexE = new GraphVertex('E');
+  const vertexF = new GraphVertex('F');
+  const vertexG = new GraphVertex('G');
+  const vertexH = new GraphVertex('H');
+
+  const edgeAB = new GraphEdge(vertexA, vertexB, 4);
+  const edgeAE = new GraphEdge(vertexA, vertexE, 7);
+  const edgeAC = new GraphEdge(vertexA, vertexC, 3);
+  const edgeBC = new GraphEdge(vertexB, vertexC, 6);
+  const edgeBD = new GraphEdge(vertexB, vertexD, 5);
+  const edgeEC = new GraphEdge(vertexE, vertexC, 8);
+  const edgeED = new GraphEdge(vertexE, vertexD, 2);
+  const edgeDC = new GraphEdge(vertexD, vertexC, 11);
+  const edgeDG = new GraphEdge(vertexD, vertexG, 10);
+  const edgeDF = new GraphEdge(vertexD, vertexF, 2);
+  const edgeFG = new GraphEdge(vertexF, vertexG, 3);
+  const edgeEG = new GraphEdge(vertexE, vertexG, 5);
+
+  const graph = new Graph(true);
+  graph
+      .addVertex(vertexH)
+      .addEdge(edgeAB)
+      .addEdge(edgeAE)
+      .addEdge(edgeAC)
+      .addEdge(edgeBC)
+      .addEdge(edgeBD)
+      .addEdge(edgeEC)
+      .addEdge(edgeED)
+      .addEdge(edgeDC)
+      .addEdge(edgeDG)
+      .addEdge(edgeDF)
+      .addEdge(edgeFG)
+      .addEdge(edgeEG);
+
+  const {dist, prev} = bellmanFord(graph, vertexA);
+
+  expect(dist['H']).toBe(Infinity);
+  expect(dist['A']).toBe(0);
+  expect(dist['B']).toBe(4);
+  expect(dist['E']).toBe(7);
+  expect(dist['C']).toBe(3);
+  expect(dist['D']).toBe(9);
+  expect(dist['G']).toBe(12);
+  expect(dist['F']).toBe(11);
+
+  expect(prev['F']).toBe('D');
+  expect(prev['D']).toBe('B');
+  expect(prev['B']).toBe('A');
+  expect(prev['G']).toBe('E');
+  expect(prev['C']).toBe('A');
+  expect(prev['A']).toBeUndefined();
+  expect(prev['H']).toBeUndefined();
+});
+
+test('should throw a negative cycle exception', () => {
+  const vertexA = new GraphVertex('A');
+  const vertexB = new GraphVertex('B');
+  const vertexC = new GraphVertex('C');
+  const vertexD = new GraphVertex('D');
+
+  const edgeAB = new GraphEdge(vertexA, vertexB, 5);
+  const edgeBC = new GraphEdge(vertexB, vertexC, 3);
+  const edgeCD = new GraphEdge(vertexC, vertexD, 2);
+  const edgeAD = new GraphEdge(vertexA, vertexD, 4);
+  const edgeDB = new GraphEdge(vertexD, vertexB, -6);
+
+  const graph = new Graph(true);
+  graph
+      .addEdge(edgeAB)
+      .addEdge(edgeBC)
+      .addEdge(edgeCD)
+      .addEdge(edgeAD)
+      .addEdge(edgeDB);
+
+  expect(() => {
+    bellmanFord(graph, vertexA);
+  }).toThrowError(new Error('Graph contains a negative-weight cycle'));
+});

src/algorithms/graph/bellman-ford/bellmanFord.ts

@@ -0,0 +1,62 @@
+/* eslint-disable no-unused-vars */
+import {Graph} from '../../../data-structures/graph/graph';
+import {GraphVertex} from '../../../data-structures/graph/graphVertex';
+
+/**
+ *
+ *
+ * @export
+ * @param {Graph} graph
+ * @param {GraphVertex} source
+ * @return {{
+ *   dist: Map<string, number>,
+ *   prev: Map<string, string>
+ * }}
+ */
+export function bellmanFord(
+    graph: Graph,
+    source: GraphVertex,
+): {
+  dist: Map<string, number>;
+  prev: Map<string, string>;
+} {
+  const dist = new Map<string, number>();
+  const prev = new Map<string, string>();
+
+  const vertices = graph.getVertices();
+  for (const vertex of vertices) {
+    dist[vertex.getKey()] = Infinity;
+    prev[vertex.getKey()] = undefined;
+  }
+  dist[source.getKey()] = 0;
+
+  const edges = graph.getEdges();
+  for (let i = 0, j = vertices.length - 1; i < j; i++) {
+    for (const edge of edges) {
+      const u = edge.startVertex.getKey();
+      const v = edge.endVertex.getKey();
+      const weight = edge.weight;
+
+      if (dist[u] + weight < dist[v]) {
+        // a new s.p. has been found
+        dist[v] = dist[u] + weight;
+        prev[v] = u;
+      }
+    }
+  }
+
+  // check for negative weight cycles
+  for (const edge of edges) {
+    const u = edge.startVertex.getKey();
+    const v = edge.endVertex.getKey();
+    const weight = edge.weight;
+    if (dist[u] + weight < dist[v]) {
+      throw new Error('Graph contains a negative-weight cycle');
+    }
+  }
+
+  return {
+    dist,
+    prev,
+  };
+}

src/algorithms/graph/dijkstra/README.md

@@ -6,6 +6,8 @@ The algorithm exists in many variants. Dijkstra's original algorithm found the s
 
 ## Applications
 
+Same as the others algorithms (e.g. Bellman-Ford) for finding the shortest path:
+
 * Searching for a shortest path
 * Build an optimal path at geographical maps
 * Network routing protocols

src/data-structures/graph/graph.ts

@@ -76,7 +76,17 @@ export class Graph {
    * @memberof Graph
    */
   getVertices(): GraphVertex[] {
-    return Object.keys(this.verticies).map((k) => this.verticies[k]) || null;
+    return Object.keys(this.verticies).map((k) => this.verticies[k]);
+  }
+
+  /**
+   *
+   *
+   * @return {GraphEdge[]}
+   * @memberof Graph
+   */
+  getEdges(): GraphEdge[] {
+    return [].concat(...this.getVertices().map((v) => v.getEdges()));
   }
 
   /**

src/data-structures/graph/graphVertex.ts

@@ -64,4 +64,12 @@ export class GraphVertex {
       return edge.startVertex === this ? edge.endVertex : edge.startVertex;
     });
   }
+
+  /**
+   * @return {GraphEdge[]}
+   * @memberof GraphVertex
+   */
+  getEdges(): GraphEdge[] {
+    return this.edges;
+  }
 }