Breadth First Search (BFS)

Breadth First Search (BFS), like Depth First Search (DFS), is a method of traversing a graph. BFS simply traverses in a different order, but otherwise is very similar to DFS.

The main difference is that BFS visits all children before any subgraphs. In a tree, we call this level order.

For the example tree above, a level order traversal would go in this order: D B F A C E G.

Step by Step

Let's see how we might implement BFS.

Some data structures we will need are:

  • A graph to traverse.

  • A queue Q to keep track of which nodes need to be processed next.

  • A list of booleans marked to keep track of which nodes were already visited.

  • (Optional) edgeTo and distTo to keep track of information that might be useful for other applications (like Dijkstra's Algorithm).

First, let's start with a vertex in the graph by marking it and adding it to the queue.

The next step is to remove A from the queue and add its children (B and C) to the queue. Also, we need to mark all of the children.

Next, we'll move onto the next item on the queue (B). We'll do the same thing that we did with A: remove B, mark all its children, and add its children to the queue. Since C is already marked, we do not add it to the queue again.

Now, we'll move on to the next item on the queue, C, and do the same thing. Again, we won't add C or A because they are both marked.

Finally, we'll visit the two remaining nodes in the queue, D and E. Since all of the nodes are marked now, there aren't any other nodes to visit.

Last updated