Cycle detection in Directed and undirected graph

Author: unfixedbug

graph/cycleDetectionInDirectedGraph.java

@@ -0,0 +1,31 @@
+import java.util.ArrayList;
+
+
+// check whether the graph is DAG, directed acyclic(without cycles) graph
+public class cycleDetectionInDirectedGraph {
+    private boolean checkCycle(int node, ArrayList<ArrayList<Integer>> adj, int[] visited, int dfsVisited[]) {
+        visited[node] = 1;
+        dfsVisited[node] = 1;
+        for (Integer child : adj.get(node)) {
+            if (visited[child] == 0) {
+                if (checkCycle(child, adj, visited, dfsVisited))
+                    return true;
+            } else if (dfsVisited[child] == 1)
+                return true;
+        }
+        return false;
+    }
+
+    public boolean isCyclic(int N, ArrayList<ArrayList<Integer>> adjlist, int n) {
+        int visited[] = new int[N];
+        int dfsVisited[] = new int[N];
+        for (int i = 0; i < n; i++) {
+            if (visited[i] == 0) {
+                if (checkCycle(i, adjlist, visited, dfsVisited) == true) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}

graph/cycledetectionInUndirectedGraph.java

@@ -0,0 +1,66 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.Queue;
+
+// CORE: if children is already visited and
+//  is not the parent of the node then there isa cycle
+public class cycledetectionInUndirectedGraph {
+    private boolean isCycle(int V, ArrayList<ArrayList<Integer>> adj) {
+        boolean[] visited = new boolean[V + 1];
+        Arrays.fill(visited, false);
+        for (int i = 1; i <= V; i++) {
+            if (!visited[i]) {
+                if (checkForCycle(adj, i, visited))
+                    return true;
+            }
+        }
+        return false;
+    }
+
+    static boolean checkForCycle(ArrayList<ArrayList<Integer>> adj, int s, boolean visited[]) {
+        Queue<Node> q = new LinkedList<>(); // bfs queue
+        q.add(new Node(s, -1)); // add source node parent of start Node is -1 <-- 0
+        visited[s] = true;
+        while (!q.isEmpty()) {
+            int node = q.peek().self;
+            int parent = q.peek().Parent;
+            q.remove();
+            for (Integer child : adj.get(node)) {
+                if (!visited[child]) {
+                    q.add(new Node(child, node));
+                    visited[child] = true;
+                } else if (child != parent) { // child is visited and is not parent, then cycle
+                    return true;
+                }
+            }
+        }
+        return false;
+
+    }
+
+    // driver code
+    public static void main(String[] args) {
+        ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
+        adj.add(new ArrayList<>(Arrays.asList(1, 2)));
+        adj.add(new ArrayList<>(Arrays.asList(2, 3)));
+        adj.add(new ArrayList<>(Arrays.asList(3, 4)));
+        // adj.add(new ArrayList<>(Arrays.asList(4, 5)));
+        cycledetectionInUndirectedGraph obj = new cycledetectionInUndirectedGraph();
+        System.out.println(obj.isCycle(4, adj));
+    }
+}
+
+class Node {
+    int self;
+    int Parent;
+
+    public Node(int self, int Parent) {
+        this.self = self;
+        this.Parent = Parent;
+    }
+}
+
+class cycleDetectionUsingDSU{
+    
+}