Topological Sort

https://www.quora.com/Why-should-I-use-a-topological-sort

Your program works with a bunch of objects. These objects may refer to some other objects that have been defined earlier. You now wish to update all objects, but of course you need to make sure that before you update object X, all objects that it refers to are updated. Therefore, you make a list of all objects, perform a topological sort, and then update all of them in the sorted order.

You would use topological sorting for problems where you have some objects that are ordered based on some rules. This is equivalent to a directed acyclic graph (DAG). A typical example would be a set of tasks where certain tasks must be executed after other ones. Then a valid execution chain is obtained by performing a topological sort on the DAG.

https://medium.com/100-days-of-algorithms/day-81-topological-sort-7a317e0c1dde

Partial ordering is very useful in many situations. One of them arises in parallel computing where a program can be represented as DAG.

X. BFS
https://www.geeksforgeeks.org/topological-sorting-indegree-based-solution/

Topological sorting for Directed Acyclic Graph (DAG) is a linear ordering of vertices such that for every directed edge uv, vertex u comes before v in the ordering. Topological Sorting for a graph is not possible if the graph is not a DAG.

A DAG G has at least one vertex with in-degree 0 and one vertex with out-degree 0.
Proof: There’s a simple proof to the above fact is that a DAG does not contain a cycle which means that all paths will be of finite length. Now let S be the longest path from u(source) to v(destination). Since S is the longest path there can be no incoming edge to u and no outgoing edge from v, if this situation had occurred then S would not have been the longest path
=> indegree(u) = 0 and outdegree(v) = 0

Algorithm:
Steps involved in finding the topological ordering of a DAG:

Step-1: Compute in-degree (number of incoming edges) for each of the vertex present in the DAG and initialize the count of visited nodes as 0.

Step-2: Pick all the vertices with in-degree as 0 and add them into a queue (Enqueue operation)

Step-3: Remove a vertex from the queue (Dequeue operation) and then.

1. Increment count of visited nodes by 1.
2. Decrease in-degree by 1 for all its neighboring nodes.
3. If in-degree of a neighboring nodes is reduced to zero, then add it to the queue.

Step 5: Repeat Step 3 until the queue is empty.

Step 5: If count of visited nodes is not equal to the number of nodes in the graph then the topological sort is not possible for the given graph.

How to find in-degree of each node?
There are 2 ways to calculate in-degree of every vertex:
Take an in-degree array which will keep track of
1) Traverse the array of edges and simply increase the counter of the destination node by 1.

for each node in Nodes
    indegree[node] = 0;
for each edge(src,dest) in Edges
    indegree[dest]++

Time Complexity: O(V+E)

2) Traverse the list for every node and then increment the in-degree of all the nodes connected to it by 1.

    for each node in Nodes
        If (list[node].size()!=0) then
        for each dest in list
            indegree[dest]++;

Time Complexity: The outer for loop will be executed V number of times and the inner for loop will be executed E number of times, Thus overall time complexity is O(V+E).

The overall time complexity of the algorithm is O(V+E)

    public void topologicalSort()

    {

        // Create a array to store indegrees of all

        // vertices. Initialize all indegrees as 0.

        int indegree[] = new int[V];

          

        // Traverse adjacency lists to fill indegrees of

        // vertices. This step takes O(V+E) time        

        for(int i = 0; i < V; i++)

        {

            ArrayList<Integer> temp = (ArrayList<Integer>) adj[i];

            for(int node : temp)

            {

                indegree[node]++;

            }

        }

          

        // Create a queue and enqueue all vertices with

        // indegree 0

        Queue<Integer> q = new LinkedList<Integer>();

        for(int i = 0;i < V; i++)

        {

            if(indegree[i]==0)

                q.add(i);

        }

          

        // Initialize count of visited vertices

        int cnt = 0;

          

        // Create a vector to store result (A topological

        // ordering of the vertices)

        Vector <Integer> topOrder=new Vector<Integer>();

        while(!q.isEmpty())

        {

            // Extract front of queue (or perform dequeue)

            // and add it to topological order

            int u=q.poll();

            topOrder.add(u);

              

            // Iterate through all its neighbouring nodes

            // of dequeued node u and decrease their in-degree

            // by 1

            for(int node : adj[u])

            {

                // If in-degree becomes zero, add it to queue

                if(--indegree[node] == 0)

                    q.add(node);

            }

            cnt++;

        }

          

        // Check if there was a cycle        

        if(cnt != V)

        {

            System.out.println("There exists a cycle in the graph");

            return ;

        }

          

        // Print topological order            

        for(int i : topOrder)

        {

            System.out.print(i+" ");

        }

    }

https://www.geeksforgeeks.org/topological-sorting/

Algorithm to find Topological Sorting:
We recommend to first see implementation of DFS here. We can modify DFS to find Topological Sorting of a graph. In DFS, we start from a vertex, we first print it and then recursively call DFS for its adjacent vertices. In topological sorting, we use a temporary stack. We don’t print the vertex immediately, we first recursively call topological sorting for all its adjacent vertices, then push it to a stack. Finally, print contents of stack. Note that a vertex is pushed to stack only when all of its adjacent vertices (and their adjacent vertices and so on) are already in stack.

    void topologicalSortUtil(int v, boolean visited[],

                             Stack stack)

    {

        // Mark the current node as visited.

        visited[v] = true;

        Integer i;

  

        // Recur for all the vertices adjacent to this

        // vertex

        Iterator<Integer> it = adj[v].iterator();

        while (it.hasNext())

        {

            i = it.next();

            if (!visited[i])

                topologicalSortUtil(i, visited, stack);

        }

  

        // Push current vertex to stack which stores result

        stack.push(new Integer(v));

    }

  

    // The function to do Topological Sort. It uses

    // recursive topologicalSortUtil()

    void topologicalSort()

    {

        Stack stack = new Stack();

  

        // Mark all the vertices as not visited

        boolean visited[] = new boolean[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

        while (stack.empty()==false)

            System.out.print(stack.pop() + " ");

    }