Merge pull request #3 from Gapur/graph

Graph

Author: Gapur

algorithms/graph/depthFirstSearch.js

@@ -0,0 +1,41 @@
+function initCallbacks(callbacks = {}) {
+  const initiatedCallback = callbacks;
+
+  const stubCallback = () => {};
+
+  const allowTraversalCallback = (
+    () => {
+      const seen = {};
+      return ({ nextVertex }) => {
+        if (!seen[nextVertex.getKey()]) {
+          seen[nextVertex.getKey()] = true;
+          return true;
+        }
+        return false;
+      };
+    }
+  )();
+
+  initiatedCallback.allowTraversal = callbacks.allowTraversal || allowTraversalCallback;
+  initiatedCallback.enterVertex = callbacks.enterVertex || stubCallback;
+  initiatedCallback.leaveVertex = callbacks.leaveVertex || stubCallback;
+
+  return initiatedCallback;
+}
+
+function depthFirstSearchRecursive(graph, currentVertex, previousVertex, callbacks) {
+  callbacks.enterVertex({ currentVertex, previousVertex });
+
+  graph.getNeighbors(currentVertex).forEach((nextVertex) => {
+    if (callbacks.allowTraversal({ previousVertex, currentVertex, nextVertex })) {
+      depthFirstSearchRecursive(graph, nextVertex, currentVertex, callbacks);
+    }
+  });
+
+  callbacks.leaveVertex({ currentVertex, previousVertex });
+}
+
+module.exports = function depthFirstSearch(graph, startVertex, callbacks) {
+  const previousVertex = null;
+  depthFirstSearchRecursive(graph, startVertex, previousVertex, initCallbacks(callbacks));
+};

algorithms/graph/dijkstra.js

@@ -0,0 +1,68 @@
+const PriorityQueue = require('../../data-structures/priority-queue/PriorityQueue');
+
+module.exports = function dijkstra(graph, startVertex) {
+  // Init helper variables that we will need for Dijkstra algorithm.
+  const distances = {};
+  const visitedVertices = {};
+  const previousVertices = {};
+  const queue = new PriorityQueue();
+
+  // Init all distances with infinity assuming that currently we can't reach
+  // any of the vertices except the start one.
+  graph.getAllVertices().forEach((vertex) => {
+    distances[vertex.getKey()] = Infinity;
+    previousVertices[vertex.getKey()] = null;
+  });
+
+  // We are already at the startVertex so the distance to it is zero.
+  distances[startVertex.getKey()] = 0;
+
+  // Init vertices queue.
+  queue.add(startVertex, distances[startVertex.getKey()]);
+
+  // Iterate over the priority queue of vertices until it is empty.
+  while (!queue.isEmpty()) {
+    // Fetch next closest vertex.
+    const currentVertex = queue.poll();
+
+    // Iterate over every unvisited neighbor of the current vertex.
+    currentVertex.getNeighbors().forEach((neighbor) => {
+      // Don't visit already visited vertices.
+      if (!visitedVertices[neighbor.getKey()]) {
+        // Update distances to every neighbor from current vertex.
+        const edge = graph.findEdge(currentVertex, neighbor);
+
+        const existingDistanceToNeighbor = distances[neighbor.getKey()];
+        const distanceToNeighborFromCurrent = distances[currentVertex.getKey()] + edge.weight;
+
+        // If we've found shorter path to the neighbor - update it.
+        if (distanceToNeighborFromCurrent < existingDistanceToNeighbor) {
+          distances[neighbor.getKey()] = distanceToNeighborFromCurrent;
+
+          // Change priority of the neighbor in a queue since it might have became closer.
+          if (queue.hasValue(neighbor)) {
+            queue.changePriority(neighbor, distances[neighbor.getKey()]);
+          }
+
+          // Remember previous closest vertex.
+          previousVertices[neighbor.getKey()] = currentVertex;
+        }
+
+        // Add neighbor to the queue for further visiting.
+        if (!queue.hasValue(neighbor)) {
+          queue.add(neighbor, distances[neighbor.getKey()]);
+        }
+      }
+    });
+
+    // Add current vertex to visited ones to avoid visiting it again later.
+    visitedVertices[currentVertex.getKey()] = currentVertex;
+  }
+
+  // Return the set of shortest distances to all vertices and the set of
+  // shortest paths to all vertices in a graph.
+  return {
+    distances,
+    previousVertices,
+  };
+};

algorithms/graph/floydWarshall.js

@@ -0,0 +1,68 @@
+module.exports = function floydWarshall(graph) {
+  // Get all graph vertices.
+  const vertices = graph.getAllVertices();
+
+  // Init previous vertices matrix with nulls meaning that there are no
+  // previous vertices exist that will give us shortest path.
+  const nextVertices = Array(vertices.length).fill(null).map(() => {
+    return Array(vertices.length).fill(null);
+  });
+
+  // Init distances matrix with Infinities meaning there are no paths
+  // between vertices exist so far.
+  const distances = Array(vertices.length).fill(null).map(() => {
+    return Array(vertices.length).fill(Infinity);
+  });
+
+  // Init distance matrix with the distance we already now (from existing edges).
+  // And also init previous vertices from the edges.
+  vertices.forEach((startVertex, startIndex) => {
+    vertices.forEach((endVertex, endIndex) => {
+      if (startVertex === endVertex) {
+        // Distance to the vertex itself is 0.
+        distances[startIndex][endIndex] = 0;
+      } else {
+        // Find edge between the start and end vertices.
+        const edge = graph.findEdge(startVertex, endVertex);
+
+        if (edge) {
+          // There is an edge from vertex with startIndex to vertex with endIndex.
+          // Save distance and previous vertex.
+          distances[startIndex][endIndex] = edge.weight;
+          nextVertices[startIndex][endIndex] = startVertex;
+        } else {
+          distances[startIndex][endIndex] = Infinity;
+        }
+      }
+    });
+  });
+
+  // Now let's go to the core of the algorithm.
+  // Let's all pair of vertices (from start to end ones) and try to check if there
+  // is a shorter path exists between them via middle vertex. Middle vertex may also
+  // be one of the graph vertices. As you may see now we're going to have three
+  // loops over all graph vertices: for start, end and middle vertices.
+  vertices.forEach((middleVertex, middleIndex) => {
+    // Path starts from startVertex with startIndex.
+    vertices.forEach((startVertex, startIndex) => {
+      // Path ends to endVertex with endIndex.
+      vertices.forEach((endVertex, endIndex) => {
+        // Compare existing distance from startVertex to endVertex, with distance
+        // from startVertex to endVertex but via middleVertex.
+        // Save the shortest distance and previous vertex that allows
+        // us to have this shortest distance.
+        const distViaMiddle = distances[startIndex][middleIndex] + distances[middleIndex][endIndex];
+
+        if (distances[startIndex][endIndex] > distViaMiddle) {
+          // We've found a shortest pass via middle vertex.
+          distances[startIndex][endIndex] = distViaMiddle;
+          nextVertices[startIndex][endIndex] = middleVertex;
+        }
+      });
+    });
+  });
+
+  // Shortest distance from x to y: distance[x][y].
+  // Next vertex after x one in path from x to y: nextVertices[x][y].
+  return { distances, nextVertices };
+};