Breadth-First Search — VisualAlgorithms Docs

How it works

Explores a graph level by level from a source vertex using a FIFO queue, visiting every vertex reachable from the source in non-decreasing order of edge distance.
Implementation

      
 function breadthFirstSearch(graph, start) {
  const order = [];
  const visited = [];
  for (let i = 0; i < graph.length; i++) {
    visited[i] = false;
  }
  const queue = [];
  let head = 0;
  let tail = 0;
  queue[tail] = start;
  tail = tail + 1;
  visited[start] = true;
  while (head < tail) {
    const node = queue[head];
    head = head + 1;
    order[order.length] = node;
    const neighbors = graph[node];
    for (let i = 0; i < neighbors.length; i++) {
      const next = neighbors[i];
      if (!visited[next]) {
        visited[next] = true;
        queue[tail] = next;
        tail = tail + 1;
      }
    }
  }
  return order;
} def breadthFirstSearch(graph, start):
    order = []
    visited = []
    for i in range(graph.length):
        visited[i] = False
    queue = []
    head = 0
    tail = 0
    queue[tail] = start
    tail = (tail + 1)
    visited[start] = True
    while (head < tail):
        node = queue[head]
        head = (head + 1)
        order[order.length] = node
        neighbors = graph[node]
        for i in range(neighbors.length):
            next_ = neighbors[i]
            if not visited[next_]:
                visited[next_] = True
                queue[tail] = next_
                tail = (tail + 1)
    return order #include <vector>
#include <algorithm>
void breadthFirstSearch(int graph, int start) {
    auto order = [];
    auto visited = [];
    for(int i=0; i<graph.length; i++) {
        visited[i] = false;
    }
    auto queue = [];
    auto head = 0;
    auto tail = 0;
    queue[tail] = start;
    tail = (tail + 1);
    visited[start] = true;
    while((head < tail)) {
        auto node = queue[head];
        head = (head + 1);
        order[order.length] = node;
        auto neighbors = graph[node];
        for(int i=0; i<neighbors.length; i++) {
            auto next_ = neighbors[i];
            if(!visited[next_]) {
                visited[next_] = true;
                queue[tail] = next_;
                tail = (tail + 1);
            }
        }
    }
    return order;
} public void breadthFirstSearch(int graph, int start) {
    var order = [];
    var visited = [];
    for(int i=0; i<graph.length; i++) {
        visited[i] = false;
    }
    var queue = [];
    var head = 0;
    var tail = 0;
    queue[tail] = start;
    tail = (tail + 1);
    visited[start] = true;
    while((head < tail)) {
        var node = queue[head];
        head = (head + 1);
        order[order.length] = node;
        var neighbors = graph[node];
        for(int i=0; i<neighbors.length; i++) {
            var next_ = neighbors[i];
            if(!visited[next_]) {
                visited[next_] = true;
                queue[tail] = next_;
                tail = (tail + 1);
            }
        }
    }
    return order;
} #include <stdio.h>
void breadthFirstSearch(int graph, int start) {
    var order = [];
    var visited = [];
    for(int i=0; i<graph.length; i++) {
        visited[i] = false;
    }
    var queue = [];
    var head = 0;
    var tail = 0;
    queue[tail] = start;
    tail = (tail + 1);
    visited[start] = true;
    while((head < tail)) {
        var node = queue[head];
        head = (head + 1);
        order[order.length] = node;
        var neighbors = graph[node];
        for(int i=0; i<neighbors.length; i++) {
            var next_ = neighbors[i];
            if(!visited[next_]) {
                visited[next_] = true;
                queue[tail] = next_;
                tail = (tail + 1);
            }
        }
    }
    return order;
} 