From 654aec92b0428258816a9f8170291181acd6e561 Mon Sep 17 00:00:00 2001
From: Dhruv Panwar <60705641+dhruvinfo28@users.noreply.github.com>
Date: Fri, 1 Oct 2021 11:14:04 +0530
Subject: [PATCH] Add Kahn's algorithm for topological sorting of a graph
 (HacktoberFest2021) (#2347)

---
 DataStructures/Graphs/KahnsAlgorithm.java | 156 ++++++++++++++++++++++
 1 file changed, 156 insertions(+)
 create mode 100644 DataStructures/Graphs/KahnsAlgorithm.java

diff --git a/DataStructures/Graphs/KahnsAlgorithm.java b/DataStructures/Graphs/KahnsAlgorithm.java
new file mode 100644
index 00000000..0dfd2f8b
--- /dev/null
+++ b/DataStructures/Graphs/KahnsAlgorithm.java
@@ -0,0 +1,156 @@
+package Graphs;
+
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.LinkedHashMap;
+import java.util.HashMap;
+import java.util.Set;
+import java.util.Queue;
+import java.util.LinkedList;
+
+/**
+ * An algorithm that sorts a graph in toplogical order.
+ */
+
+/**
+ * A class that represents the adjaceny list of a graph
+ */
+class AdjacencyList<E extends Comparable<E>>{
+    
+    Map<E,ArrayList<E>> adj;
+    
+    AdjacencyList(){
+        adj = new LinkedHashMap<E,ArrayList<E>>();
+    }
+    
+    /**
+     * This function adds an Edge to the adjaceny list
+     * @param from , the vertex the edge is from
+     * @param to, the vertex the edge is going to
+     */
+    void addEdge(E from, E to){
+        try{
+             adj.get(from).add(to);
+        }
+        catch(Exception E){
+            adj.put(from,new ArrayList<E>());
+            adj.get(from).add(to);
+        }
+        if(!adj.containsKey(to)){
+            adj.put(to, new ArrayList<E>());
+        }
+    }
+    
+    /**
+     * @param v, A vertex in a graph
+     * @return returns an ArrayList of all the adjacents of vertex v
+     */
+    ArrayList<E> getAdjacents(E v){
+        return adj.get(v);
+    }
+    
+    /** 
+     * @return returns a set of all vertices in the graph
+     */
+    Set<E> getVertices(){
+        return adj.keySet();
+    }
+    
+    /**
+     * Prints the adjacency list
+     */
+    void printGraph(){
+        for(E vertex: adj.keySet()){
+            System.out.print(vertex+" : ");
+            for(E adjacent: adj.get(vertex)){
+                System.out.print(adjacent+" ");
+            }
+            System.out.println();
+        }
+    }
+}
+
+class TopologicalSort<E extends Comparable<E>>{
+    AdjacencyList<E> graph;
+    Map<E,Integer> inDegree;
+    
+    TopologicalSort(AdjacencyList<E> graph){
+        this.graph = graph;
+    }
+    
+    
+    /**
+     * Calculates the in degree of all vertices
+     */
+    void calculateInDegree(){
+        inDegree = new HashMap<>();
+        for(E vertex: graph.getVertices()){
+            if(!inDegree.containsKey(vertex)){
+                inDegree.put(vertex,0);
+            }
+            for(E adjacent: graph.getAdjacents(vertex)){
+                try{
+                    inDegree.put(adjacent,inDegree.get(adjacent) + 1);
+                }
+                catch(Exception e){
+                    inDegree.put(adjacent,1);
+                }
+            }
+        }
+    }
+    
+    /**
+     * Returns an ArrayList with vertices arranged in topological order
+     */
+    ArrayList<E> topSortOrder(){
+        calculateInDegree();
+        int count = 0;
+        Queue<E> q = new LinkedList<E>();
+        
+        for(E vertex: inDegree.keySet()){
+            if(inDegree.get(vertex) == 0){
+                q.add(vertex);
+            }
+        }
+        
+        ArrayList<E> answer = new ArrayList<>();
+        
+        while(!q.isEmpty()){
+            E current = q.poll();
+            answer.add(current);
+            for(E adjacent: graph.getAdjacents(current)){
+                inDegree.put(adjacent,inDegree.get(adjacent)-1);
+                if(inDegree.get(adjacent) == 0){
+                    q.add(adjacent);
+                }
+            }
+        }
+        
+        return answer;
+        
+    }
+}
+
+/**
+ * A driver class that sorts a given graph in topological order.
+ */ 
+public class KahnsAlgorithm{
+    public static void main(String[] args){
+        
+        //Graph definition and initialization
+        AdjacencyList<String> graph = new AdjacencyList<>();
+        graph.addEdge("a","b");
+        graph.addEdge("c","a");
+        graph.addEdge("a","d");
+        graph.addEdge("b","d");
+        graph.addEdge("c","u");
+        graph.addEdge("u","b");
+        
+        TopologicalSort<String> topSort = new TopologicalSort<>(graph);
+        
+        //Printing the order
+        for(String s: topSort.topSortOrder()){
+            System.out.print(s+" ");
+        }
+    }
+}
\ No newline at end of file