Add a topological sort algorithm, which is based on the dfs algorithm

Author: FSou1

src/algorithms/graph/depth-first-search/depthFirstSearch.ts

@@ -44,7 +44,9 @@ function depthFirstSearchRecursive(
 
   const neighbors = graph.getNeighbors(currentVertex);
   for (const neighbor of neighbors) {
-    depthFirstSearch(graph, neighbor, config);
+    if (config.allowEnterVertex(neighbor)) {
+      depthFirstSearch(graph, neighbor, config);
+    }
   }
 
   config.leaveVertex(currentVertex);

src/algorithms/graph/topological/README.md

@@ -0,0 +1,8 @@
+# Topological sort
+
+A topological sort or topological ordering of a directed graph is a linear ordering of its vertices such that for every directed edge `uv` from vertex `u` to vertex `v`, `u` comes before `v` in the ordering.
+
+## References
+
+- [Youtube](https://youtu.be/AfSk24UTFS8?t=2508);
+- [Wikipedia](https://en.wikipedia.org/wiki/Topological_sorting);

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

@@ -0,0 +1,51 @@
+import {topological} from '../topological';
+import {Graph} from '../../../../data-structures/graph/graph';
+import {GraphEdge} from '../../../../data-structures/graph/graphEdge';
+import {GraphVertex} from '../../../../data-structures/graph/graphVertex';
+
+test('should perform topological on graph', () => {
+  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 edgeAC = new GraphEdge(vertexA, vertexC);
+  const edgeBC = new GraphEdge(vertexB, vertexC);
+  const edgeBD = new GraphEdge(vertexB, vertexD);
+  const edgeCE = new GraphEdge(vertexC, vertexE);
+  const edgeDF = new GraphEdge(vertexD, vertexF);
+  const edgeEF = new GraphEdge(vertexE, vertexF);
+  const edgeEH = new GraphEdge(vertexE, vertexH);
+  const edgeFG = new GraphEdge(vertexF, vertexG);
+
+  const graph = new Graph(true);
+
+  graph
+      .addEdge(edgeAC)
+      .addEdge(edgeBC)
+      .addEdge(edgeBD)
+      .addEdge(edgeCE)
+      .addEdge(edgeDF)
+      .addEdge(edgeEF)
+      .addEdge(edgeEH)
+      .addEdge(edgeFG);
+
+  const sortedVertices = topological(graph);
+
+  expect(sortedVertices).toBeDefined();
+  expect(sortedVertices.length).toBe(graph.getVertices().length);
+  expect(sortedVertices).toEqual([
+    vertexB,
+    vertexD,
+    vertexA,
+    vertexC,
+    vertexE,
+    vertexH,
+    vertexF,
+    vertexG,
+  ]);
+});

src/algorithms/graph/topological/topological.ts

@@ -0,0 +1,71 @@
+/* eslint-disable no-unused-vars */
+import {Graph} from '../../../data-structures/graph/graph';
+import {GraphVertex} from '../../../data-structures/graph/graphVertex';
+import {GraphConfig} from '../../../data-structures/graph/graphConfig';
+import {depthFirstSearch} from '../depth-first-search/depthFirstSearch';
+
+/**
+ *
+ *
+ * @export
+ * @param {Graph} graph
+ * @param {GraphConfig} config
+ * @return {GraphVertex[]}
+ */
+export function topological(
+    graph: Graph,
+    config: GraphConfig = null,
+): GraphVertex[] {
+  if (!graph) {
+    return;
+  }
+
+  // A set of unvisited vertices
+  const unvisited = {};
+  graph.getVertices().forEach((vertex) => {
+    unvisited[vertex.getKey()] = vertex;
+  });
+
+  // A set of visited vertices
+  const visited = {};
+
+  // An array, which behaves like a stack (to hold the order)
+  const stack = [];
+
+  config = config || ({} as GraphConfig);
+
+  // Visit only unvisited vertices
+  config.allowEnterVertex =
+    config.allowEnterVertex ||
+    ((vertex: GraphVertex) => {
+      return !visited[vertex.getKey()];
+    });
+
+  config.enterVertex =
+    config.enterVertex ||
+    ((vertex: GraphVertex) => {
+      // Remove a vertex from the unvisited set
+      delete unvisited[vertex.getKey()];
+
+      // Mark a vertex as visited
+      visited[vertex.getKey()] = vertex;
+    });
+
+  /* Push the vertex onto the stack,
+   * when all of the vertex neighbors have been visited */
+  config.leaveVertex =
+    config.leaveVertex ||
+    ((vertex: GraphVertex) => {
+      // TODO: Replace with an actual stack implementation
+      stack.push(vertex);
+    });
+
+  while (Object.keys(unvisited).length) {
+    const startVertexKey = Object.keys(unvisited)[0];
+    const startVertex = unvisited[startVertexKey];
+
+    depthFirstSearch(graph, startVertex, config);
+  }
+
+  return stack.reverse();
+}

src/data-structures/graph/graphVertex.ts

@@ -1,6 +1,5 @@
 /* eslint-disable no-unused-vars */
 import {GraphEdge} from './graphEdge';
-import {Graph} from './graph';
 
 /**
  *