Connected Components Using BFS in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the visited array for BFS.

DSA Java

boolean[] visited = new boolean[[1]];

Drag options to blanks, or click blank then click option'

Agraph.length + 1

Bgraph[0].length

Cgraph.size()

Dgraph.length

Attempts:

3 left

💡 Hint

Common Mistakes

Using graph[0].length instead of graph.length

Using graph.size() which is invalid for arrays

The visited array size should match the number of nodes, which is graph.length.

2fill in blank

medium

Complete the code to add the starting node to the BFS queue.

DSA Java

Queue<Integer> queue = new LinkedList<>();
queue.[1](start);

Drag options to blanks, or click blank then click option'

AaddAll

Boffer

Cpush

Denqueue

Attempts:

3 left

💡 Hint

Common Mistakes

Using push() which is for stacks

Using enqueue() which is not a Java Queue method

In Java's Queue interface, offer() adds an element to the queue safely.

3fill in blank

hard

Fix the error in the BFS loop condition to process nodes until the queue is empty.

DSA Java

while (!queue.[1]()) {
    int node = queue.poll();
    // process node
}

Drag options to blanks, or click blank then click option'

Aempty

BhasNext

CisEmpty

DisNotEmpty

Attempts:

3 left

💡 Hint

Common Mistakes

Using empty() which does not exist

Using hasNext() which is for iterators

The correct method to check if a queue is empty is isEmpty().

4fill in blank

hard

Fill both blanks to mark a node visited and add its neighbors to the queue if unvisited.

DSA Java

visited[node] = [1];
for (int neighbor : graph[node]) {
    if (!visited[neighbor]) {
        queue.[2](neighbor);
    }
}

Drag options to blanks, or click blank then click option'

Atrue

Bfalse

Coffer

Dadd

Attempts:

3 left

💡 Hint

Common Mistakes

Marking visited as false

Using add() which can throw exceptions

Mark the node as visited by setting true, and add neighbors using offer() to the queue.

5fill in blank

hard

Fill all three blanks to complete the connected components count using BFS.

DSA Java

int count = 0;
for (int i = 0; i < [1]; i++) {
    if (!visited[i]) {
        bfs(graph, i, visited);
        count [2] [3];
    }
}

Drag options to blanks, or click blank then click option'

Agraph.length

B+=

C1

D--

Attempts:

3 left

💡 Hint

Common Mistakes

Using graph[0].length

Using -- instead of incrementing count

Loop over all nodes using graph.length, increment count by 1 for each new component found.

Practice

1. What does the BFS algorithm help find in an undirected graph when used for connected components?

easy

A. The shortest path between two nodes only

B. The degree of each node

C. The total number of edges in the graph

D. All nodes reachable from a starting node forming one connected component

Solution

1. Step 1: Understand BFS in graph context

   BFS explores all nodes reachable from a given start node by visiting neighbors level by level.

2. Step 2: Connect BFS to connected components

   By running BFS from an unvisited node, we find all nodes in that node's connected component.

3. Final Answer:

   All nodes reachable from a starting node forming one connected component -> Option D

4. Quick Check:

   BFS finds connected components by exploring reachable nodes [OK]

Hint: BFS visits all nodes in one connected group [OK]

Common Mistakes:

• Thinking BFS only finds shortest paths
• Confusing connected components with edge count
• Assuming BFS finds node degrees

2. Which of the following is the correct Java syntax to initialize a queue for BFS traversal?

easy

A. Queue<Integer> queue = new LinkedList<>();

B. Queue<Integer> queue = new ArrayList<>();

C. Queue<Integer> queue = new Stack<>();

D. Queue<Integer> queue = new HashSet<>();

Solution

1. Step 1: Identify correct Queue implementation

   Java's Queue interface is commonly implemented by LinkedList for BFS.

2. Step 2: Check other options

   ArrayList is not a Queue, Stack is LIFO not FIFO, HashSet is a Set, not a Queue.

3. Final Answer:

   Queue<Integer> queue = new LinkedList<>(); -> Option A

4. Quick Check:

   LinkedList implements Queue for BFS [OK]

Hint: Use LinkedList for Queue in BFS [OK]

Common Mistakes:

• Using ArrayList instead of Queue
• Using Stack which is LIFO, not FIFO
• Using HashSet which is unordered

3. What is the output of the following code snippet that uses BFS to count connected components in a graph?

int n = 5;
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(2).add(3);
graph.get(3).add(2);
boolean[] visited = new boolean[n];
int count = 0;
for (int i = 0; i < n; i++) {
  if (!visited[i]) {
    Queue<Integer> queue = new LinkedList<>();
    queue.add(i);
    visited[i] = true;
    while (!queue.isEmpty()) {
      int node = queue.poll();
      for (int nei : graph.get(node)) {
        if (!visited[nei]) {
          visited[nei] = true;
          queue.add(nei);
        }
      }
    }
    count++;
  }
}
System.out.println(count);

medium

A. 3

B. 2

C. 1

D. 4

Solution

1. Step 1: Analyze graph edges

   Edges connect nodes 0-1 and 2-3. Node 4 is isolated.

2. Step 2: Count connected components

   Components are {0,1}, {2,3}, and {4} -> total 3 components.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   3 connected groups found [OK]

Hint: Count isolated and connected groups carefully [OK]

Common Mistakes:

• Ignoring isolated nodes
• Counting edges instead of components
• Misreading graph connections

4. Identify the bug in this BFS code snippet for counting connected components:

for (int i = 0; i < n; i++) {
  if (!visited[i]) {
    Queue<Integer> queue = new LinkedList<>();
    queue.add(i);
    while (!queue.isEmpty()) {
      int node = queue.poll();
      for (int nei : graph.get(node)) {
        if (!visited[nei]) {
          queue.add(nei);
          visited[nei] = true;
        }
      }
    }
    count++;
  }
}

medium

A. Graph adjacency list is empty

B. visited[i] is not set to true before BFS

C. count++ is inside the inner loop

D. Queue is not initialized properly

Solution

1. Step 1: Check visited marking

   visited[i] should be set true when node i is added to queue to avoid revisiting.

2. Step 2: Identify missing visited update

   Code adds i to queue but does not mark visited[i] true before BFS loop.

3. Final Answer:

   visited[i] is not set to true before BFS -> Option B

4. Quick Check:

   Mark visited when adding to queue [OK]

Hint: Always mark visited when enqueueing nodes [OK]

Common Mistakes:

• Marking visited after dequeueing
• Not initializing queue correctly
• Incrementing count inside BFS loop

5. Given a graph with 7 nodes and edges: (0-1), (1-2), (3-4), (5-6), how many connected components will BFS find if run on all nodes? Also, which nodes belong to the largest component?

hard

A. 2 connected components; largest component nodes: [0, 1, 2, 3, 4]

B. 3 connected components; largest component nodes: [3, 4, 5, 6]

C. 3 connected components; largest component nodes: [0, 1, 2]

D. 5 connected components; largest component nodes: [5, 6]

Solution

1. Step 1: Identify connected groups

   Edges form groups: {0,1,2}, {3,4}, {5,6} -- total 3 components (nodes 0-6).

2. Step 2: Count components and largest group

   3 components total. Largest is {0,1,2} with 3 nodes.

3. Final Answer:

   3 connected components; largest component nodes: [0, 1, 2] -> Option C

4. Quick Check:

   3 components, largest size 3 [OK]

Hint: Group nodes by edges; largest group has most nodes [OK]

Common Mistakes:

• Counting nodes incorrectly
• Missing isolated nodes
• Mixing node indices