BFS Traversal - Problem

Given a graph represented as an adjacency list, implement Breadth-First Search (BFS) traversal starting from a given source node.

Return the traversal order as a list of integers. BFS explores nodes level by level, visiting all neighbors at the current depth before moving to nodes at the next depth level.

Note: The graph is represented as an adjacency list where graph[i] contains all neighbors of node i. Nodes are numbered from 0 to n-1.

Input & Output

Example 1 — Simple Connected Graph

$ Input: graph = [[1,2],[0,3],[0],[1]], start = 0

› Output: [0,1,2,3]

💡 Note: Starting at node 0, we first visit 0, then its neighbors 1 and 2 (level 1), then node 3 which is neighbor of 1 (level 2)

Example 2 — Linear Chain

$ Input: graph = [[1],[0,2],[1,3],[2]], start = 0

› Output: [0,1,2,3]

💡 Note: Linear chain 0-1-2-3: visit 0, then 1, then 2, then 3 in breadth-first order

Example 3 — Single Node

$ Input: graph = [[]], start = 0

› Output: [0]

💡 Note: Single isolated node with no neighbors, BFS returns just the start node

Constraints

1 ≤ graph.length ≤ 1000
0 ≤ graph[i].length ≤ 1000
0 ≤ graph[i][j] ≤ graph.length - 1
0 ≤ start < graph.length

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 M Microsoft 28

The key insight is to use a queue to process nodes level by level, ensuring true breadth-first traversal. Best approach uses queue-based BFS with visited tracking. Time: O(V + E), Space: O(V)

Common Approaches

✓ Queue-Based BFS

⏱️ Time: O(V + E) Space: O(V)

Implement proper BFS using a queue data structure. Start with the source node, add its unvisited neighbors to the queue, then process each node in queue order.

Recursive DFS with Visited Check

⏱️ Time: O(V + E) Space: O(V)

Implement BFS using recursive DFS approach where we go as deep as possible before backtracking. This defeats the purpose of BFS level-order traversal but works for basic connectivity.

Queue-Based BFS — Algorithm Steps

Initialize queue with start node and visited set
While queue not empty, dequeue front node
Add node to result and mark as visited
Enqueue all unvisited neighbors
Repeat until queue is empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with source node in queue

Process Level 1

Visit all direct neighbors

Process Level 2

Visit neighbors of neighbors

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_NODES 1000
int visited[MAX_NODES];
int result[MAX_NODES];
int resultSize = 0;
int queue[MAX_NODES];
int front = 0, rear = 0;
int graph[MAX_NODES][MAX_NODES];
int graphSize[MAX_NODES];

int* solution(int n, int start, int* returnSize) {
    memset(visited, 0, sizeof(visited));
    resultSize = 0;
    front = rear = 0;
    
    queue[rear++] = start;
    visited[start] = 1;
    
    while (front < rear) {
        int node = queue[front++];
        result[resultSize++] = node;
        
        for (int i = 0; i < graphSize[node]; i++) {
            int neighbor = graph[node][i];
            if (!visited[neighbor]) {
                visited[neighbor] = 1;
                queue[rear++] = neighbor;
            }
        }
    }
    
    *returnSize = resultSize;
    return result;
}

int main() {
    // Initialize sample graph: [[1,2],[0,3],[0],[1]]
    int n = 4;
    int start = 0;
    
    graphSize[0] = 2; graph[0][0] = 1; graph[0][1] = 2;
    graphSize[1] = 2; graph[1][0] = 0; graph[1][1] = 3;
    graphSize[2] = 1; graph[2][0] = 0;
    graphSize[3] = 1; graph[3][0] = 1;
    
    int returnSize;
    int* result = solution(n, start, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each vertex once and examine each edge once

✓ Linear Growth

Space Complexity

O(V)

Queue can hold up to V nodes, plus visited set of size V

✓ Linear Space

23.4K Views

High Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

BFS Traversal - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Queue-Based BFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler