142 lines
6.2 KiB
Markdown
142 lines
6.2 KiB
Markdown
---
|
|
id: 587d825c367417b2b2512c90
|
|
title: Breadth-First Search
|
|
challengeType: 1
|
|
forumTopicId: 301622
|
|
---
|
|
|
|
## Description
|
|
<section id='description'>
|
|
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 <dfn>graph traversal algorithms</dfn>.
|
|
<dfn>Traversal algorithms</dfn> 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 and so on until all nodes have been reached.
|
|
Visually, this is what the algorithm is doing.
|
|
<img class='img-responsive' src='https://camo.githubusercontent.com/2f57e6239884a1a03402912f13c49555dec76d06/68747470733a2f2f75706c6f61642e77696b696d656469612e6f72672f77696b6970656469612f636f6d6d6f6e732f342f34362f416e696d617465645f4246532e676966'>
|
|
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 <code>Infinity</code>. 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 <dfn>FIFO</dfn> or <dfn>First-In-First-Out</dfn> data structure.
|
|
</section>
|
|
|
|
## Instructions
|
|
<section id='instructions'>
|
|
Write a function <code>bfs()</code> 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 <code>0</code> and <code>n - 1</code>, where <code>n</code> 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 <code>Infinity</code>.
|
|
</section>
|
|
|
|
## Tests
|
|
<section id='tests'>
|
|
|
|
```yml
|
|
tests:
|
|
- text: 'The input graph <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> with a start node of <code>1</code> should return <code>{0: 1, 1: 0, 2: 1, 3: 2}</code>'
|
|
testString: 'assert((function() { var graph = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]; var results = bfs(graph, 1); return isEquivalent(results, {0: 1, 1: 0, 2: 1, 3: 2})})());'
|
|
- text: 'The input graph <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> with a start node of <code>1</code> should return <code>{0: 1, 1: 0, 2: 1, 3: Infinity}</code>'
|
|
testString: 'assert((function() { var graph = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]; var results = bfs(graph, 1); return isEquivalent(results, {0: 1, 1: 0, 2: 1, 3: Infinity})})());'
|
|
- text: 'The input graph <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> with a start node of <code>0</code> should return <code>{0: 0, 1: 1, 2: 2, 3: 3}</code>'
|
|
testString: 'assert((function() { var graph = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]; var results = bfs(graph, 0); return isEquivalent(results, {0: 0, 1: 1, 2: 2, 3: 3})})());'
|
|
- text: 'The input graph <code>[[0, 1], [1, 0]]</code> with a start node of <code>0</code> should return <code>{0: 0, 1: 1}</code>'
|
|
testString: 'assert((function() { var graph = [[0, 1], [1, 0]]; var results = bfs(graph, 0); return isEquivalent(results, {0: 0, 1: 1})})());'
|
|
|
|
```
|
|
|
|
</section>
|
|
|
|
## Challenge Seed
|
|
<section id='challengeSeed'>
|
|
|
|
<div id='js-seed'>
|
|
|
|
```js
|
|
function bfs(graph, root) {
|
|
// Distance object returned
|
|
var nodesLen = {};
|
|
|
|
return nodesLen;
|
|
};
|
|
|
|
var exBFSGraph = [
|
|
[0, 1, 0, 0],
|
|
[1, 0, 1, 0],
|
|
[0, 1, 0, 1],
|
|
[0, 0, 1, 0]
|
|
];
|
|
console.log(bfs(exBFSGraph, 3));
|
|
```
|
|
|
|
</div>
|
|
|
|
|
|
### After Test
|
|
<div id='js-teardown'>
|
|
|
|
```js
|
|
// Source: http://adripofjavascript.com/blog/drips/object-equality-in-javascript.html
|
|
function isEquivalent(a, b) {
|
|
// Create arrays of property names
|
|
var aProps = Object.getOwnPropertyNames(a);
|
|
var bProps = Object.getOwnPropertyNames(b);
|
|
// If number of properties is different,
|
|
// objects are not equivalent
|
|
if (aProps.length != bProps.length) {
|
|
return false;
|
|
}
|
|
for (var i = 0; i < aProps.length; i++) {
|
|
var propName = aProps[i];
|
|
// If values of same property are not equal,
|
|
// objects are not equivalent
|
|
if (a[propName] !== b[propName]) {
|
|
return false;
|
|
}
|
|
}
|
|
// If we made it this far, objects
|
|
// are considered equivalent
|
|
return true;
|
|
}
|
|
```
|
|
|
|
</div>
|
|
|
|
</section>
|
|
|
|
## Solution
|
|
<section id='solution'>
|
|
|
|
|
|
```js
|
|
function bfs(graph, root) {
|
|
// Distance object returned
|
|
var nodesLen = {};
|
|
// Set all distances to infinity
|
|
for (var i = 0; i < graph.length; i++) {
|
|
nodesLen[i] = Infinity;
|
|
}
|
|
nodesLen[root] = 0; // ...except root node
|
|
var queue = [root]; // Keep track of nodes to visit
|
|
var current; // Current node traversing
|
|
// Keep on going until no more nodes to traverse
|
|
while (queue.length !== 0) {
|
|
current = queue.shift();
|
|
// Get adjacent nodes from current node
|
|
var curConnected = graph[current]; // Get layer of edges from current
|
|
var neighborIdx = []; // List of nodes with edges
|
|
var idx = curConnected.indexOf(1); // Get first edge connection
|
|
while (idx !== -1) {
|
|
neighborIdx.push(idx); // Add to list of neighbors
|
|
idx = curConnected.indexOf(1, idx + 1); // Keep on searching
|
|
}
|
|
// Loop through neighbors and get lengths
|
|
for (var j = 0; j < neighborIdx.length; j++) {
|
|
// Increment distance for nodes traversed
|
|
if (nodesLen[neighborIdx[j]] === Infinity) {
|
|
nodesLen[neighborIdx[j]] = nodesLen[current] + 1;
|
|
queue.push(neighborIdx[j]); // Add new neighbors to queue
|
|
}
|
|
}
|
|
}
|
|
return nodesLen;
|
|
}
|
|
```
|
|
|
|
</section>
|