广度优先搜索

广度优先搜索（BFS：Breadth-First Search）是一种图搜索策略，其将搜索限制到 2 种操作：

• (a) 访问图中的一个节点；
• (b) 访问该节点的邻居节点；

广度优先搜索（BFS）由 Edward F. Moore 在 1950 年发表，起初被用于在迷宫中寻找最短路径。在 Prim 最小生成树算法和 Dijkstra 单源最短路径算法中，都采用了与广度优先搜索类似的思想。

对图的广度优先搜索与对树（Tree）的广度优先遍历（Breadth First Traversal）是类似的，区别在于图中可能存在环，所以可能会遍历到已经遍历的节点。BFD 算法首先会发现和源顶点 s 距离边数为 k 的所有顶点，然后才会发现和 s 距离边数为 k+1 的其他顶点。

例如，下面的图中，从顶点 2 开始遍历，当遍历到顶点 0 时，邻接的顶点为 1 和 2，而顶点 2 已经遍历过，如果不做标记，遍历过程将陷入死循环。所以，在 BFS 的算法实现中需要对顶点是否访问过做标记。

上图的 BFS 遍历结果为 [ 2, 0, 3, 1 ]。

BFS 算法的实现通常使用队列（Queue）数据结构来存储遍历图中节点的中间状态，过程如下：

1. 将 root 节点 Enqueue；
2. Dequeue 一个节点，并检查该节点：
   • 如果该节点就是要找的目标节点，则结束遍历，返回结果 "Found"；
   • 否则，Enqueue 所有直接后继子节点（如果节点未被访问过）；
3. 如果 Queue 为空，并且图中的所有节点都被检查过，仍未找到目标节点，则结束搜索，返回结果 "Not Found"；
4. 如果 Queue 不为空，重复步骤 2；

如果需要记录搜索的轨迹，可以为顶点着色。起初所有顶点为白色，随着搜索的进行变为灰色，然后变成黑色。灰色和黑色顶点都是已发现的顶点。

BFS 算法伪码如下：

procedure BFS(G,v) is
    create a queue Q
    create a set V
    add v to V
    enqueue v onto Q
    while Q is not empty loop
       t = Q.dequeue()
       if t is what we are looking for then
          return t
       end if
       for all edges e in G.adjacentEdges(t) loop
          u = G.adjacentVertex(t,e)
          if u is not in V then
              add u to V
              enqueue u onto Q
          end if
       end loop
    end loop
    return none
end BFS

广度优先搜索（BFS）的时间复杂度为 O(V+E)，V 即 Vertex 顶点数量，E 即 Edge 边数量。

BFS 算法实现代码如下：

using System;
using System.Collections.Generic;

namespace GraphAlgorithmTesting
{
  class Program
  {
    static void Main(string[] args)
    {
      Graph g = new Graph(4);
      g.AddEdge(0, 1);
      g.AddEdge(0, 2);
      g.AddEdge(1, 2);
      g.AddEdge(2, 0);
      g.AddEdge(2, 3);
      g.AddEdge(3, 3);

      List<int> traversal = g.BFS(2);
      foreach (var vertex in traversal)
      {
        Console.WriteLine(vertex);
      }

      Console.ReadKey();
    }

    class Edge
    {
      public Edge(int begin, int end)
      {
        this.Begin = begin;
        this.End = end;
      }

      public int Begin { get; private set; }
      public int End { get; private set; }
    }

    class Graph
    {
      private Dictionary<int, List<Edge>> _adjacentEdges
        = new Dictionary<int, List<Edge>>();

      public Graph(int vertexCount)
      {
        this.VertexCount = vertexCount;
      }

      public int VertexCount { get; private set; }

      public void AddEdge(int begin, int end)
      {
        if (!_adjacentEdges.ContainsKey(begin))
        {
          var edges = new List<Edge>();
          _adjacentEdges.Add(begin, edges);
        }

        _adjacentEdges[begin].Add(new Edge(begin, end));
      }

      public List<int> BFS(int start)
      {
        List<int> traversal = new List<int>();
        int current = start;

        // mark all the vertices as not visited
        bool[] visited = new bool[VertexCount];
        for (int i = 0; i < VertexCount; i++)
        {
          visited[i] = false;
        }

        // create a queue for BFS
        Queue<int> queue = new Queue<int>();

        // mark the current node as visited and enqueue it
        visited[current] = true;
        queue.Enqueue(current);

        while (queue.Count > 0)
        {
          current = queue.Dequeue();

          // if this is what we are looking for
          traversal.Add(current);

          // get all adjacent vertices of the dequeued vertex,
          // if a adjacent has not been visited, 
          // then mark it visited and enqueue it
          if (_adjacentEdges.ContainsKey(current))
          {
            foreach (var edge in _adjacentEdges[current])
            {
              if (!visited[edge.End])
              {
                visited[edge.End] = true;
                queue.Enqueue(edge.End);
              }
            }
          }
        }

        return traversal;
      }
    }
  }
}

参考资料

• 广度优先搜索
• 深度优先搜索
• Breadth First Traversal for a Graph
• Depth First Traversal for a Graph
• Introduction to Algorithms 6.006 - Lecture 13

本篇文章《广度优先搜索》由 Dennis Gao 发表自博客园，未经作者本人同意禁止任何形式的转载，任何自动或人为的爬虫转载行为均为耍流氓。