feat(graph): implement topological sort

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/index.js

@@ -5,6 +5,7 @@ const dijkstra = require('./dijkstra');
 const prim = require('./prim');
 const kruskal = require('./kruskal');
 const floydWarshall = require('./floydWarshall');
+const topologicalSort = require('./topologicalSort');
 
 console.log('start Graph -------');
 
@@ -179,4 +180,42 @@ console.log(`distances \n ${disFw.map((d) => `- ${d.join(', ')} - \n`).join(' ')
 
 console.log('end floydWarshall --------');
 
+console.log('start topologicalSort');
+
+const tsVertexA = new GraphVertex('A');
+const tsVertexB = new GraphVertex('B');
+const tsVertexC = new GraphVertex('C');
+const tsVertexD = new GraphVertex('D');
+const tsVertexE = new GraphVertex('E');
+const tsVertexF = new GraphVertex('F');
+const tsVertexG = new GraphVertex('G');
+const tsVertexH = new GraphVertex('H');
+
+const tsEdgeAC = new GraphEdge(tsVertexA, tsVertexC);
+const tsEdgeBC = new GraphEdge(tsVertexB, tsVertexC);
+const tsEdgeBD = new GraphEdge(tsVertexB, tsVertexD);
+const tsEdgeCE = new GraphEdge(tsVertexC, tsVertexE);
+const tsEdgeDF = new GraphEdge(tsVertexD, tsVertexF);
+const tsEdgeEF = new GraphEdge(tsVertexE, tsVertexF);
+const tsEdgeEH = new GraphEdge(tsVertexE, tsVertexH);
+const tsEdgeFG = new GraphEdge(tsVertexF, tsVertexG);
+
+const graphForTS = new Graph(true);
+
+graphForTS
+  .addEdge(tsEdgeAC)
+  .addEdge(tsEdgeBC)
+  .addEdge(tsEdgeBD)
+  .addEdge(tsEdgeCE)
+  .addEdge(tsEdgeDF)
+  .addEdge(tsEdgeEF)
+  .addEdge(tsEdgeEH)
+  .addEdge(tsEdgeFG);
+
+const sortedVertices = topologicalSort(graphForTS);
+
+console.log(`graph ${graphForTS.toString()} sortedVertices ${sortedVertices.toString()}`);
+
+console.log('end topologicalSort');
+
 module.exports = () => console.log('Graph is done');

algorithms/graph/topologicalSort.js

@@ -0,0 +1,44 @@
+const Stack = require('../../data-structures/stack/Stack');
+const depthFirstSearch = require('./depthFirstSearch');
+
+module.exports = function topologicalSort(graph) {
+  // Create a set of all vertices we want to visit.
+  const unvisitedSet = {};
+  graph.getAllVertices().forEach((vertex) => {
+    unvisitedSet[vertex.getKey()] = vertex;
+  });
+
+  // Create a set for all vertices that we've already visited.
+  const visitedSet = {};
+
+  // Create a stack of already ordered vertices.
+  const sortedStack = new Stack();
+
+  const dfsCallbacks = {
+    enterVertex: ({ currentVertex }) => {
+      // Add vertex to visited set in case if all its children has been explored.
+      visitedSet[currentVertex.getKey()] = currentVertex;
+
+      // Remove this vertex from unvisited set.
+      delete unvisitedSet[currentVertex.getKey()];
+    },
+    leaveVertex: ({ currentVertex }) => {
+      // If the vertex has been totally explored then we may push it to stack.
+      sortedStack.push(currentVertex);
+    },
+    allowTraversal: ({ nextVertex }) => {
+      return !visitedSet[nextVertex.getKey()];
+    },
+  };
+
+  // Let's go and do DFS for all unvisited nodes.
+  while (Object.keys(unvisitedSet).length) {
+    const currentVertexKey = Object.keys(unvisitedSet)[0];
+    const currentVertex = unvisitedSet[currentVertexKey];
+
+    // Do DFS for current node.
+    depthFirstSearch(graph, currentVertex, dfsCallbacks);
+  }
+
+  return sortedStack.toArray();
+};