From d18edd8c046786d971d2099c41ba1fb6684d03d8 Mon Sep 17 00:00:00 2001
From: mahammadhussain98 <141554718+mahammadhussain98@users.noreply.github.com>
Date: Mon, 2 Oct 2023 18:58:08 +0530
Subject: [PATCH] added Topological sort

Topological Sort is an algorithm for arranging the vertices of a directed graph (DAG) in a linear order such that for every directed edge (u, v), vertex u comes before vertex v in the ordering. It's often used to represent tasks with dependencies, ensuring that tasks are executed in the correct order. The algorithm typically employs depth-first search (DFS) and is valuable for scheduling and optimizing tasks in various applications like project planning and build systems.
---
 sorting/Topological Sort.cpp | 109 +++++++++++++++++++++++++++++++++++
 1 file changed, 109 insertions(+)
 create mode 100644 sorting/Topological Sort.cpp

diff --git a/sorting/Topological Sort.cpp b/sorting/Topological Sort.cpp
new file mode 100644
index 000000000..baf06d9c2
--- /dev/null
+++ b/sorting/Topological Sort.cpp	
@@ -0,0 +1,109 @@
+#include <iostream>
+#include <list>
+#include <stack>
+#include <string>
+#include <sstream>
+using namespace std;
+
+// Class to represent a graph
+class Graph {
+    int V; // No. of vertices
+
+    // Pointer to an array containing adjacency lists
+    list<int>* adj;
+
+    // A function used by topologicalSort
+    void topologicalSortUtil(int v, bool visited[], stack<int>& Stack);
+
+public:
+    Graph(int V); // Constructor
+
+    // Function to add an edge to the graph
+    void addEdge(int v, int w);
+
+    // Prints a Topological Sort of the complete graph
+    void topologicalSort();
+};
+
+Graph::Graph(int V)
+{
+    this->V = V;
+    adj = new list<int>[V];
+}
+
+void Graph::addEdge(int v, int w)
+{
+    adj[v].push_back(w); // Add w to v’s list.
+}
+
+// A recursive function used by topologicalSort
+void Graph::topologicalSortUtil(int v, bool visited[],
+    stack<int>& Stack)
+{
+    // Mark the current node as visited.
+    visited[v] = true;
+
+    // Recur for all the vertices adjacent to this vertex
+    list<int>::iterator i;
+    for (i = adj[v].begin(); i != adj[v].end(); ++i)
+        if (!visited[*i])
+            topologicalSortUtil(*i, visited, Stack);
+
+    // Push current vertex to stack which stores result
+    Stack.push(v);
+}
+
+// The function to do Topological Sort. It uses recursive
+// topologicalSortUtil()
+void Graph::topologicalSort()
+{
+    stack<int> Stack;
+
+    // Mark all the vertices as not visited
+    bool* visited = new bool[V];
+    for (int i = 0; i < V; i++)
+        visited[i] = false;
+
+    // Call the recursive helper function to store Topological
+    // Sort starting from all vertices one by one
+    for (int i = 0; i < V; i++)
+        if (visited[i] == false)
+            topologicalSortUtil(i, visited, Stack);
+
+    // Print contents of stack
+    cout << "Topological Sort: ";
+    while (Stack.empty() == false) {
+        cout << Stack.top() << " ";
+        Stack.pop();
+    }
+}
+
+int main()
+{
+    int V;
+    string edgeInput;
+
+    cout << "Enter the number of vertices: ";
+    cin >> V;
+
+    cin.ignore(); // Ignore the newline character
+
+    Graph g(V);
+
+    cout << "Enter the edges as a comma-separated list (e.g., 1,2,3,):" << endl;
+    getline(cin, edgeInput);
+
+    istringstream iss(edgeInput);
+    string edge;
+    while (getline(iss, edge, ',')) {
+        int source, destination;
+        source = stoi(edge);
+        getline(iss, edge, ',');
+        destination = stoi(edge);
+        g.addEdge(source, destination);
+    }
+
+    g.topologicalSort();
+
+    return 0;
+}