Introduction

Breadth-first search visits nodes level by level, so depth is naturally available if you carry the right state through the queue. The two standard approaches are storing (node, depth) pairs directly or processing the queue one level at a time.

Pair Each Node With Its Depth

The most explicit approach is to push both the node and its depth into the queue. When you dequeue the node, you already know how far it is from the start.

1from collections import deque
2
3
4def bfs_with_depth(graph, start):
5    visited = {start}
6    queue = deque([(start, 0)])
7
8    while queue:
9        node, depth = queue.popleft()
10        print(f"visit {node} at depth {depth}")
11
12        for neighbor in graph[node]:
13            if neighbor not in visited:
14                visited.add(neighbor)
15                queue.append((neighbor, depth + 1))
16
17
18graph = {
19    "A": ["B", "C"],
20    "B": ["D", "E"],
21    "C": ["F"],
22    "D": [],
23    "E": [],
24    "F": []
25}
26
27bfs_with_depth(graph, "A")

This is usually the simplest version to explain and debug because the queue state makes the depth explicit.

Process One Level at a Time

Another common pattern is to track the current level outside the queue. At each step, you process exactly the number of nodes already in the queue, because those nodes all belong to the same depth.

1from collections import deque
2
3
4def bfs_by_level(graph, start):
5    visited = {start}
6    queue = deque([start])
7    depth = 0
8
9    while queue:
10        level_size = len(queue)
11        print(f"depth {depth}:")
12
13        for _ in range(level_size):
14            node = queue.popleft()
15            print(f"  {node}")
16
17            for neighbor in graph[node]:
18                if neighbor not in visited:
19                    visited.add(neighbor)
20                    queue.append(neighbor)
21
22        depth += 1
23
24
25bfs_by_level(graph, "A")

This pattern is especially useful when the task itself is level-based, such as printing layers of a tree or finding the minimum number of moves in an unweighted graph.

Use a Distance Map When You Need Lookup Later

If you need to remember the depth of every node after BFS finishes, a distance dictionary is often the cleanest representation.

1from collections import deque
2
3
4def bfs_distances(graph, start):
5    distances = {start: 0}
6    queue = deque([start])
7
8    while queue:
9        node = queue.popleft()
10
11        for neighbor in graph[node]:
12            if neighbor not in distances:
13                distances[neighbor] = distances[node] + 1
14                queue.append(neighbor)
15
16    return distances
17
18
19print(bfs_distances(graph, "A"))

This is effectively depth tracking with a more reusable output structure. It is also the standard shortest-path distance map for an unweighted graph.

Trees and Graphs Need Slightly Different Attention

In a tree, you can often skip a visited set if you already know the parent-child structure prevents cycles. In a general graph, you need visited tracking or a distance map so that BFS does not revisit nodes forever.

That matters for depth correctness too. If a node is enqueued multiple times through different parents, the recorded depth can become noisy unless you mark it the first time it is discovered.

Which Approach Should You Use

Use (node, depth) pairs when:

• you want the clearest implementation
• you need the depth while processing each node

Use level-by-level iteration when:

• the problem is naturally phrased by layers
• you need to do one action per level rather than per node-depth pair

Use a distance map when:

• you need to query depths later
• the BFS is really computing shortest path lengths

All three are valid. The best choice depends on what the rest of the problem needs.

Common Pitfalls

The biggest mistake is incrementing a global depth counter every time a node is popped. That does not reflect BFS depth; it only counts how many nodes were processed.

Another common issue is forgetting visited tracking in graphs with cycles. Without it, BFS can revisit nodes endlessly or assign misleading depths.

People also sometimes mark nodes as visited too late. Mark them when enqueueing, not when dequeueing, so the same node is not added multiple times.

Finally, do not mix level-based logic with pair-based logic unless you truly need both. Pick one depth-tracking pattern and keep it consistent.

Summary

• BFS depth is easiest to track by storing (node, depth) in the queue or by processing one level at a time.
• A distance dictionary is the best choice when you need the depths after traversal.
• In graphs, mark nodes as visited when they are enqueued.
• A single global counter per popped node does not represent BFS depth correctly.
• Choose the tracking style that matches the rest of the problem, not just the traversal itself.