Cycle Detection in Undirected Graph in DSA Java

Mental Model

We want to find if there is a loop in a graph where you can start at one node and come back to it by following edges without retracing the same edge immediately.

Analogy: Imagine walking in a park with paths connecting benches. If you can walk around and return to the same bench without turning back on the path you just came from, there is a cycle.

0 -> 1
↑    ↓
3 ← 2

Nodes connected with edges, showing a cycle 0-1-2-3-0

Dry Run Walkthrough

Input: Graph with edges: 0-1, 1-2, 2-3, 3-0 (cycle exists)

Goal: Detect if the graph contains a cycle

Step 1: Start DFS from node 0, mark 0 visited

Visited: {0}
Stack: [0]

Why: We begin traversal from node 0 to explore connected nodes

Step 2: From 0, visit neighbor 1, mark 1 visited

Visited: {0,1}
Stack: [0,1]

Why: Explore next node connected to 0

Step 3: From 1, visit neighbor 2, mark 2 visited

Visited: {0,1,2}
Stack: [0,1,2]

Why: Continue deeper to find cycle

Step 4: From 2, visit neighbor 3, mark 3 visited

Visited: {0,1,2,3}
Stack: [0,1,2,3]

Why: Keep exploring neighbors

Step 5: From 3, neighbor 0 is visited and not parent, cycle detected

Cycle found at node 3 via neighbor 0

Why: Visiting a visited node that is not parent means a cycle

Result:

Cycle detected in the graph

Annotated Code

DSA Java

import java.util.*;

public class CycleDetectionUndirected {

    static class Graph {
        int V;
        List<List<Integer>> adj;

        Graph(int V) {
            this.V = V;
            adj = new ArrayList<>();
            for (int i = 0; i < V; i++) {
                adj.add(new ArrayList<>());
            }
        }

        void addEdge(int u, int v) {
            adj.get(u).add(v);
            adj.get(v).add(u);
        }
    }

    static boolean dfs(int node, int parent, boolean[] visited, List<List<Integer>> adj) {
        visited[node] = true; // mark current node visited
        for (int neighbor : adj.get(node)) {
            if (!visited[neighbor]) {
                if (dfs(neighbor, node, visited, adj)) {
                    return true; // cycle found in deeper call
                }
            } else if (neighbor != parent) {
                return true; // visited neighbor not parent means cycle
            }
        }
        return false; // no cycle found from this node
    }

    static boolean isCycle(Graph graph) {
        boolean[] visited = new boolean[graph.V];
        for (int i = 0; i < graph.V; i++) {
            if (!visited[i]) {
                if (dfs(i, -1, visited, graph.adj)) {
                    return true; // cycle detected
                }
            }
        }
        return false; // no cycle in any component
    }

    public static void main(String[] args) {
        Graph graph = new Graph(4);
        graph.addEdge(0, 1);
        graph.addEdge(1, 2);
        graph.addEdge(2, 3);
        graph.addEdge(3, 0);

        System.out.println(isCycle(graph) ? "Cycle detected in the graph" : "No cycle detected");
    }
}

visited[node] = true; // mark current node visited

mark current node as visited to avoid revisiting

if (!visited[neighbor]) { if (dfs(neighbor, node, visited, adj)) { return true; } }

visit unvisited neighbors recursively to explore deeper

else if (neighbor != parent) { return true; }

detect cycle if neighbor is visited and not the parent node

for (int i = 0; i < graph.V; i++) { if (!visited[i]) { if (dfs(i, -1, visited, graph.adj)) { return true; } } }

check all disconnected components for cycles

Output

Cycle detected in the graph

Complexity Analysis

Time: O(V + E) because we visit each vertex and edge once during DFS

Space: O(V) for the visited array and recursion stack in worst case

vs Alternative: Compared to using union-find, DFS is intuitive and easy to implement but union-find can be faster for dynamic edge additions

Edge Cases

Empty graph with no edges

No cycle detected because no edges exist

DSA Java

for (int i = 0; i < graph.V; i++) { if (!visited[i]) { if (dfs(i, -1, visited, graph.adj)) { return true; } } }

Graph with a single node and no edges

No cycle detected because no edges to form cycle

DSA Java

for (int i = 0; i < graph.V; i++) { if (!visited[i]) { if (dfs(i, -1, visited, graph.adj)) { return true; } } }

Graph with multiple disconnected components, one with cycle

Cycle detected in the component that contains a cycle

DSA Java

for (int i = 0; i < graph.V; i++) { if (!visited[i]) { if (dfs(i, -1, visited, graph.adj)) { return true; } } }

When to Use This Pattern

When you need to check if an undirected graph has loops, use DFS with parent tracking to detect cycles efficiently.

Common Mistakes

Mistake: Not checking if the visited neighbor is the parent node, causing false cycle detection
Fix: Add condition to ignore the parent node when checking visited neighbors

Summary

Detects if an undirected graph contains any cycle using DFS.

Use when you want to know if a graph has loops that can cause repeated traversal.

The key is to track the parent node to avoid mistaking the immediate back edge as a cycle.

Practice

1. What is the main idea behind detecting a cycle in an undirected graph using DFS?

easy

A. If the graph has more edges than nodes, it always has a cycle.

B. If all nodes are visited exactly once, the graph has a cycle.

C. If the graph is disconnected, it contains a cycle.

D. If we visit a node that is already visited and is not the parent, a cycle exists.

Solution

1. Step 1: Understand DFS traversal in undirected graph

   DFS visits nodes and tracks the parent node to avoid false cycle detection.

2. Step 2: Detect cycle condition

   If during DFS, a visited node is found that is not the parent, it means a back edge exists, indicating a cycle.

3. Final Answer:

   If we visit a node that is already visited and is not the parent, a cycle exists. -> Option D

4. Quick Check:

   Cycle detection in undirected graph = check visited node not parent [OK]

Hint: Check visited nodes excluding parent during DFS to find cycles [OK]

Common Mistakes:

• Confusing parent node with visited node
• Assuming disconnected graph always has cycles
• Thinking more edges than nodes always means cycle

2. Which of the following Java method signatures is correct for a DFS function used in cycle detection in an undirected graph?

easy

A. boolean dfs(int node, boolean[] visited, List graph)

B. void dfs(int node, int parent, boolean[] visited, List<Integer> graph)

C. boolean dfs(int node, int parent, boolean[] visited, List graph)

D. int dfs(int node, int parent, boolean[] visited, List graph)

Solution

1. Step 1: Identify parameters needed for DFS cycle detection

   DFS needs current node, parent node, visited array, and adjacency list graph.

2. Step 2: Check return type and parameter types

   Return type boolean indicates if cycle found; graph must be List of Lists for adjacency; parent is needed.

3. Final Answer:

   boolean dfs(int node, int parent, boolean[] visited, List<List<Integer>> graph) -> Option C

4. Quick Check:

   DFS signature with parent and boolean return = boolean dfs(int node, int parent, boolean[] visited, List graph) [OK]

Hint: DFS needs parent node and boolean return for cycle detection [OK]

Common Mistakes:

• Using void return type instead of boolean
• Passing graph as List<Integer> instead of List
• Omitting parent parameter

3. What will be the output of the following Java code snippet detecting cycle in an undirected graph?

import java.util.*;
public class GraphCycle {
    static boolean dfs(int node, int parent, boolean[] visited, List graph) {
        visited[node] = true;
        for (int adj : graph.get(node)) {
            if (!visited[adj]) {
                if (dfs(adj, node, visited, graph)) return true;
            } else if (adj != parent) {
                return true;
            }
        }
        return false;
    }
    public static void main(String[] args) {
        int n = 4;
        List graph = new ArrayList<>();
        for (int i = 0; i < n; i++) graph.add(new ArrayList<>());
        graph.get(0).add(1); graph.get(1).add(0);
        graph.get(1).add(2); graph.get(2).add(1);
        graph.get(2).add(3); graph.get(3).add(2);
        graph.get(3).add(1); graph.get(1).add(3);
        boolean[] visited = new boolean[n];
        boolean hasCycle = false;
        for (int i = 0; i < n; i++) {
            if (!visited[i]) {
                if (dfs(i, -1, visited, graph)) {
                    hasCycle = true;
                    break;
                }
            }
        }
        System.out.println(hasCycle);
    }
}

medium

A. true

B. false

C. Compilation error

D. Runtime exception

Solution

1. Step 1: Analyze graph edges and structure

   Graph edges: 0-1, 1-2, 2-3, 3-1 form a cycle (1-2-3-1).

2. Step 2: Trace DFS cycle detection logic

   DFS finds visited node 1 again from 3 (not parent), so returns true indicating cycle.

3. Final Answer:

   true -> Option A

4. Quick Check:

   Cycle detected in graph = true [OK]

Hint: Look for back edge to visited node not parent to confirm cycle [OK]

Common Mistakes:

• Ignoring the edge 3-1 that closes the cycle
• Assuming no cycle because graph is connected
• Misunderstanding parent check in DFS

4. Identify the bug in the following Java code snippet for cycle detection in an undirected graph:

boolean dfs(int node, int parent, boolean[] visited, List graph) {
    visited[node] = true;
    for (int adj : graph.get(node)) {
        if (!visited[adj]) {
            dfs(adj, node, visited, graph);
        } else if (adj != parent) {
            return true;
        }
    }
    return false;
}

medium

A. Incorrect parent check condition

B. Missing return statement for recursive dfs call result

C. Visited array not updated correctly

D. Graph adjacency list type is wrong

Solution

1. Step 1: Review recursive DFS calls

   Recursive call dfs(adj, node, visited, graph) is made but its boolean result is ignored.

2. Step 2: Understand impact of ignoring return value

   If a cycle is detected deeper, it won't propagate true back, causing false negatives.

3. Final Answer:

   Missing return statement for recursive dfs call result -> Option B

4. Quick Check:

   Return recursive call result to detect cycles correctly [OK]

Hint: Always return recursive DFS call result when checking for cycles [OK]

Common Mistakes:

• Not returning true from recursive calls
• Confusing parent check logic
• Not marking nodes visited before recursion

5. Given an undirected graph represented as adjacency list:

0: [1, 2]
1: [0, 3]
2: [0, 3]
3: [1, 2, 4]
4: [3]

Which of the following modifications will correctly detect a cycle in this graph using DFS cycle detection method?

hard

A. Start DFS from node 0 and pass -1 as parent; check visited nodes for back edges.

B. Start DFS from node 4 only; ignore parent parameter in DFS calls.

C. Use BFS instead of DFS without parent tracking to detect cycles.

D. Mark nodes visited after all recursive calls complete.

Solution

1. Step 1: Understand graph structure and cycle presence

   Edges form a cycle: 0-1-3-2-0. Starting DFS from 0 covers all nodes.

2. Step 2: Apply correct DFS cycle detection method

   Starting DFS from 0 with parent -1 and checking visited nodes excluding parent detects cycle correctly.

3. Final Answer:

   Start DFS from node 0 and pass -1 as parent; check visited nodes for back edges. -> Option A

4. Quick Check:

   Proper DFS start and parent check detects cycle [OK]

Hint: Start DFS from any node with parent -1 and track visited nodes [OK]

Common Mistakes:

• Ignoring parent parameter causing false positives
• Starting DFS from leaf node only
• Marking visited nodes too late