Add the basic implementation of the Dijkstra's algorithm

Author: FSou1

README.md

@@ -31,6 +31,7 @@ An algorithm is a finite sequence of well-defined, computer-implementable instru
 * **Graph**
   * [Breadth-first search](src/algorithms/graph/breadth-first-search) - traverse a graph, explore neighbor vertices first;
   * [Depth-first search](src/algorithms/graph/depth-first-search) - traverse a graph, explore descendant vertices first;
+  * [Dijkstra](src/algorithms/graph/dijkstra) - find the shortest path between two vertices in a graph, return a shortest-path tree;
 
 ## How to use this repository
 

package.json

@@ -4,7 +4,7 @@
   "description": "Algorithms and data structures implemented in TypeScript",
   "author": "Maxim Zhukov (https://www.linkedin.com/in/maxim-zhukov-0648a8b5)",
   "scripts": {
-    "lint": "eslint ./src/*",
+    "lint": "eslint ./src/**/*.ts",
     "test": "jest"
   },
   "repository": {

src/algorithms/graph/dijkstra/README.md

@@ -0,0 +1,22 @@
+# Dijkstra
+
+Dijkstra's algorithm (or Dijkstra's Shortest Path First algorithm, SPF algorithm) is an algorithm for finding the shortest paths between nodes in a graph, which may represent, for example, road networks. It was conceived by computer scientist Edsger W. Dijkstra in 1956 and published three years later.
+
+The algorithm exists in many variants. Dijkstra's original algorithm found the shortest path between two given nodes, but a more common variant fixes a single node as the "source" node and finds shortest paths from the source to all other nodes in the graph, producing a shortest-path tree.
+
+## Applications
+
+* Searching for a shortest path
+* Build an optimal path at geographical maps
+* Network routing protocols
+
+## Complexity
+
+**Time Complexity**: TBD.
+
+**Space Complexity**: TBD.
+
+## References
+
+- [Youtube](https://www.youtube.com/watch?v=2E7MmKv0Y24);
+- [Wikipedia](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm);

src/algorithms/graph/dijkstra/__tests__/dijkstra.test.ts

@@ -0,0 +1,64 @@
+import {Graph} from '../../../../data-structures/graph/graph';
+import {GraphVertex} from '../../../../data-structures/graph/graphVertex';
+import {GraphEdge} from '../../../../data-structures/graph/graphEdge';
+import {dijkstra} from '../dijsktra';
+
+test('should return shortest paths to vertices', () => {
+  const graph = new Graph(true);
+
+  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);
+
+  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} = dijkstra(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();
+});

src/algorithms/graph/dijkstra/dijsktra.ts

@@ -0,0 +1,75 @@
+/* eslint-disable no-unused-vars */
+import {Graph} from '../../../data-structures/graph/graph';
+import {GraphVertex} from '../../../data-structures/graph/graphVertex';
+import {Queue} from '../../../data-structures/queue/queue';
+
+/**
+ *
+ *
+ * @export
+ * @param {Graph} graph
+ * @param {GraphVertex} source
+ * @return {{
+ *   dist: Map<string, number>,
+ *   prev: Map<string, string>
+ * }}
+ */
+export function dijkstra(
+    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 visited = new Map<string, boolean>();
+
+  for (const vertex of graph.getVertices()) {
+    dist[vertex.getKey()] = Infinity;
+    prev[vertex.getKey()] = undefined;
+  }
+  dist[source.getKey()] = 0;
+
+  const queue = new Queue<GraphVertex>();
+  queue.enqueue(source);
+  while (!queue.isEmpty()) {
+    const currentVertex = queue.dequeue();
+
+    const neighbors = currentVertex.getNeighbors();
+    for (const neighbor of neighbors) {
+      if (!visited[neighbor.getKey()]) {
+        const edge = graph.findEdge(currentVertex, neighbor);
+
+        const path = dist[currentVertex.getKey()] + edge.weight;
+        if (path < dist[neighbor.getKey()]) {
+          // a new s.p. has been found
+          dist[neighbor.getKey()] = path;
+          prev[neighbor.getKey()] = currentVertex.getKey();
+        }
+      }
+    }
+
+    // mark as visited
+    visited[currentVertex.getKey()] = true;
+
+    // enqueue next vertex
+    let minDistance = Infinity;
+    let nextVertex = null;
+    for (const vertex of graph.getVertices()) {
+      if (!visited[vertex.getKey()]) {
+        if (dist[vertex.getKey()] < minDistance) {
+          minDistance = dist[vertex.getKey()];
+          nextVertex = vertex;
+        }
+      }
+    }
+
+    // TODO: replace with priority queue
+    if (nextVertex) {
+      queue.enqueue(nextVertex);
+    }
+  }
+
+  return {dist, prev};
+}

src/algorithms/search/peak-finder/2d/__tests__/peakFinder2d.test.ts

@@ -14,7 +14,6 @@ test('a peak of [2x2] is 3', () => {
     [2, 3],
   ];
   const peak = 3;
-  debugger;
   expect(findPeak(arr)).toBe(peak);
 });
 

src/data-structures/graph/graph.ts

@@ -9,8 +9,8 @@ import {GraphEdge} from './graphEdge';
  * @class Graph
  */
 export class Graph {
-  directed: boolean;
-  verticies: {};
+  private directed: boolean;
+  private verticies: {};
 
   /**
    * Creates an instance of Graph.
@@ -69,6 +69,16 @@ export class Graph {
     return this.verticies[vertex.getKey()] || null;
   }
 
+  /**
+   *
+   *
+   * @return {GraphVertex[]}
+   * @memberof Graph
+   */
+  getVertices(): GraphVertex[] {
+    return Object.keys(this.verticies).map((k) => this.verticies[k]) || null;
+  }
+
   /**
    * @param {GraphVertex} vertex
    * @return {GraphVertex[]}
@@ -78,6 +88,21 @@ export class Graph {
     return this.getVertex(vertex).getNeighbors();
   }
 
+  /**
+   * @param {GraphVertex} start
+   * @param {GraphVertex} end
+   * @return {GraphEdge}
+   * @memberof Graph
+   */
+  findEdge(start: GraphVertex, end: GraphVertex): GraphEdge {
+    const vertex = this.getVertex(start);
+    if (!vertex) {
+      return null;
+    }
+
+    return vertex.findEdge(end);
+  }
+
   /**
    * @return {string}
    * @memberof Graph

src/data-structures/graph/graphEdge.ts

@@ -10,15 +10,18 @@ import {GraphVertex} from './graphVertex';
 export class GraphEdge {
   startVertex: GraphVertex;
   endVertex: GraphVertex;
+  weight: number;
 
   /**
    *Creates an instance of GraphEdge.
    * @param {GraphVertex} startVertex
    * @param {GraphVertex} endVertex
+   * @param {number} [weight=0]
    * @memberof GraphEdge
    */
-  constructor(startVertex: GraphVertex, endVertex: GraphVertex) {
+  constructor(startVertex: GraphVertex, endVertex: GraphVertex, weight = 0) {
     this.startVertex = startVertex;
     this.endVertex = endVertex;
+    this.weight = weight;
   }
 }

src/data-structures/graph/graphVertex.ts

@@ -1,5 +1,6 @@
-// eslint-disable-next-line no-unused-vars
+/* eslint-disable no-unused-vars */
 import {GraphEdge} from './graphEdge';
+import {Graph} from './graph';
 
 /**
  *
@@ -8,8 +9,8 @@ import {GraphEdge} from './graphEdge';
  * @class GraphVertex
  */
 export class GraphVertex {
-  key: string;
-  edges: GraphEdge[];
+  private key: string;
+  private edges: GraphEdge[];
 
   /**
    *Creates an instance of GraphVertex.
@@ -39,6 +40,19 @@ export class GraphVertex {
     return this;
   }
 
+  /**
+   * @param {GraphVertex} vertex
+   * @return {GraphEdge}
+   * @memberof GraphVertex
+   */
+  findEdge(vertex: GraphVertex): GraphEdge {
+    const edge = this.edges.filter((edge) => {
+      return edge.startVertex === vertex || edge.endVertex === vertex;
+    });
+
+    return edge[0] ?? null;
+  }
+
   /**
    * @return {GraphVertex[]}
    * @memberof GraphVertex