Cycle Detection in Undirected Graph in DSA Java - Build from Scratch

Cycle Detection in Undirected Graph

📖 Scenario: You are working on a network system where devices are connected by cables. You want to check if there is any loop (cycle) in the connections because loops can cause problems in the network.

🎯 Goal: Build a Java program that represents an undirected graph using adjacency lists and detects if there is a cycle in the graph.

📋 What You'll Learn

Create an undirected graph using adjacency lists

Use a depth-first search (DFS) approach to detect cycles

Track visited nodes and parent nodes during DFS

Print true if a cycle exists, otherwise false

💡 Why This Matters

🌍 Real World

Cycle detection helps in network design to avoid loops that can cause data packet storms or broadcast issues.

💼 Career

Understanding graph traversal and cycle detection is important for software engineers working on networking, dependency resolution, and system design.

1

Create the graph data structure

Create a Java class called Graph with an integer variable V for the number of vertices and an adjacency list array adj of type LinkedList<Integer>[]. Initialize adj in the constructor for V = 5 vertices.

DSA Java

import java.util.LinkedList;

public class Graph {
    int V;
    LinkedList[] adj;

    public Graph() {
        // Your code here
    }
}

Hint

Use a loop to initialize each element of the adjacency list array with a new LinkedList.

2

Add edges to the graph

Add a method addEdge(int v, int w) in the Graph class that adds an undirected edge by adding w to adj[v] and v to adj[w]. Then, in the main method, create a Graph object and add these edges: (0,1), (1,2), (2,3), (3,4), (4,1).

DSA Java

import java.util.LinkedList;

public class Graph {
    int V;
    LinkedList[] adj;

    public Graph() {
        V = 5;
        adj = new LinkedList[V];
        for (int i = 0; i ();
        }
    }

    // Add addEdge method here

    public static void main(String[] args) {
        Graph g = new Graph();
        // Add edges here
    }
}

Hint

Remember to add edges in both directions for an undirected graph.

3

Implement cycle detection logic

Add a method isCyclic() in the Graph class that returns true if the graph contains a cycle, otherwise false. Use a boolean array visited to track visited vertices. Use a helper method isCyclicUtil(int v, boolean[] visited, int parent) that performs DFS and checks for cycles by verifying if a visited adjacent vertex is not the parent.

DSA Java

import java.util.LinkedList;

public class Graph {
    int V;
    LinkedList[] adj;

    public Graph() {
        V = 5;
        adj = new LinkedList[V];
        for (int i = 0; i ();
        }
    }

    void addEdge(int v, int w) {
        adj[v].add(w);
        adj[w].add(v);
    }

    // Add isCyclic and isCyclicUtil methods here

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

Hint

Use DFS to visit nodes and check if a visited node is found that is not the parent.

4

Print the cycle detection result

In the main method, after adding edges, print the result of g.isCyclic() using System.out.println.

DSA Java

import java.util.LinkedList;

public class Graph {
    int V;
    LinkedList[] adj;

    public Graph() {
        V = 5;
        adj = new LinkedList[V];
        for (int i = 0; i ();
        }
    }

    void addEdge(int v, int w) {
        adj[v].add(w);
        adj[w].add(v);
    }

    boolean isCyclicUtil(int v, boolean[] visited, int parent) {
        visited[v] = true;
        for (int i : adj[v]) {
            if (!visited[i]) {
                if (isCyclicUtil(i, visited, v)) {
                    return true;
                }
            } else if (i != parent) {
                return true;
            }
        }
        return false;
    }

    boolean isCyclic() {
        boolean[] visited = new boolean[V];
        for (int u = 0; u < V; u++) {
            if (!visited[u]) {
                if (isCyclicUtil(u, visited, -1)) {
                    return true;
                }
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Graph g = new Graph();
        g.addEdge(0, 1);
        g.addEdge(1, 2);
        g.addEdge(2, 3);
        g.addEdge(3, 4);
        g.addEdge(4, 1);
        // Print cycle detection result below
    }
}

Hint

Use System.out.println(g.isCyclic()) to print the result.

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