Once you feel ready, you can get real-world experience by contributing to these open source tools used by nonprofits.

So far, we've learned different ways of creating representations of graphs. What now? One natural question to have is what are the distances between any two nodes in the graph? Enter graph traversal algorithms.

Traversal algorithms are algorithms to traverse or visit nodes in a graph. One type of traversal algorithm is the breadth-first search algorithm.

This algorithm starts at one node, first visits all its neighbors that are one edge away, then goes on to visiting each of their neighbors.

Visually, this is what the algorithm is doing.

To implement this algorithm, you'll need to input a graph structure and a node you want to start at.

First, you'll want to be aware of the distances from the start node. This you'll want to start all your distances initially some large number, like `Infinity`

. This gives a reference for the case where a node may not be reachable from your start node.

Next, you'll want to go from the start node to its neighbors. These neighbors are one edge away and at this point you should add one unit of distance to the distances you're keeping track of.

Last, an important data structure that will help implement the breadth-first search algorithm is the queue. This is an array where you can add elements to one end and remove elements from the other end. This is also known as a FIFO or First-In-First-Out data structure.

Write a function `bfs()`

that takes an adjacency matrix graph (a two-dimensional array) and a node label root as parameters. The node label will just be the integer value of the node between `0`

and `n - 1`

, where `n`

is the total number of nodes in the graph.

Your function will output a JavaScript object key-value pairs with the node and its distance from the root. If the node could not be reached, it should have a distance of `Infinity`

.

The input graph

`[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]`

with a start node of `1`

should return `{0: 1, 1: 0, 2: 1, 3: 2}`

The input graph

`[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]`

with a start node of `1`

should return `{0: 1, 1: 0, 2: 1, 3: Infinity}`

The input graph

`[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]`

with a start node of `0`

should return `{0: 0, 1: 1, 2: 2, 3: 3}`

The input graph

`[[0, 1], [1, 0]]`

with a start node of `0`

should return `{0: 0, 1: 1}`