BFS (Level Order Traversal)

广度优先搜索算法（Breadth-First-Search），又译作宽度优先搜索，或横向优先搜索，简称BFS，是一种图形搜索算法。简单的说，BFS是从根节点开始，沿着树的宽度遍历树的节点。如果所有节点均被访问，则算法中止。广度优先搜索的实现一般采用open-closed表。

特性

 

空间复杂度

因为所有节点都必须被储存，因此BFS的空间复杂度为 O(|V| + |E|)，其中 |V| 是节点的数目，而 |E| 是图中边的数目。注：另一种说法称BFS的空间复杂度为 O(B^M)，其中 B 是最大分支系数，而 M 是树的最长路径长度。由于对空间的大量需求，因此BFS并不适合解非常大的问题。

时间复杂度

最差情形下，BFS必须寻找所有到可能节点的所有路径，因此其时间复杂度为 O(|V| + |E|)，其中 |V| 是节点的数目，而 |E| 是图中边的数目。

最佳解

若所有边的长度相等，广度优先搜索算法是最佳解——亦即它找到的第一个解，距离根节点的边数目一定最少；但对一般的图来说，BFS并不一定回传最佳解。这是因为当图形为加权图（亦即各边长度不同）时，BFS仍然回传从根节点开始，经过边数目最少的解；而这个解距离根节点的距离不一定最短。这个问题可以使用考虑各边权值，BFS的改良算法成本一致搜寻法（en:uniform-cost search）来解决。然而，若非加权图形，则所有边的长度相等，BFS就能找到最近的最佳解。

广度优先搜索算法的应用

 

广度优先搜索算法能用来解决图论中的许多问题，例如：

• 寻找图中所有连接元件（Connected Component）。一个连接元件是图中的最大相连子图。 
• 寻找连接元件中的所有节点。 
• 寻找非加权图中任两点的最短路径。 
• 测试一图是否为二分图。 
• (Reverse) Cuthill–McKee算法

 

寻找连接元件

由起点开始，执行广度优先搜索算法后所经过的所有节点，即为包含起点的一个连接元件。

广度优先搜索,即BFS(Breadth First Search)，是一种相当常用的图算法，其特点是：每次搜索指定点，并将其所有未访问过的邻近节点加入搜索队列，循环搜索过程直到队列为空。

        算法描述如下：

        （1）将起始节点放入队列尾部

         （2）While(队列不为空）

取得并删除队列首节点Node

                          处理该节点Node

                          把Node的未处理相邻节点加入队列尾部

         使用该算法注意的问题：

        （1）使用该算法关键的数据结构为：队列，队列保证了广度渡优先，并且每个节点都被处理到

         （2）新加入的节点一般要是未处理过的，所以某些情况下最初要对所有节点进行标记

         （3）广度优先在实际使用时，很对情况已超出图论的范围，将新节点加入队列的条件不再局限于

相邻节点这个概念。例如，使用广度优先的网络爬虫在抓取网页时，会把一个链接指向的网页中的所有

URL加入队列供后续处理。

         典型实例：

        1.图的遍历（VC6.0/VS2005)

////////////////////////////////// 
//广度优先之节点遍历 
//1-----5----------9 
//|        |              | 
//|        |              |   
//2-----4----6-----8 
//|               |         | 
//|             |         | 
//3----------7-----10 
// 1 2 3 4 5 6 7 8 
//1 0 1 0 0 1 0 0 0 
//2 1 0 1 1 0 0 0 0 
//3 0 1 0 0 0 0 1 0 
//4 0 1 0 0 1 1 0 0 
//5 1 0 0 1 0 0 0 0 
//6 0 0 0 1 0 0 1 1 
//7 0 0 1 0 0 1 0 0 
//8 0 0 0 0 0 1 0 0

#include 
#include 
using namespace std;

//节点数 
#define M 10

//图的矩阵表示 
int matrix[M][M] = 
{ 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 
1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 
0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 
0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 
1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 
0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 
0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 
0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 
0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 
0, 0, 0, 0, 0, 0, 1, 1, 0, 0

}; 
//访问标记,初始化为0, 
int visited[M + 1];

//graph traverse 
void GT_BFS() 
{ 
visited[1] = 1; 
queue q; 
q.push(1); 
while(!q.empty()) 
{ 
   int top = q.front(); 
   cout << top<<" ";//输出 
   q.pop(); 
   int i ; 
   for(i = 1; i <= M; ++i) 
   { 
    if(visited[i] == 0 && matrix[top - 1][i - 1 ] == 1) 
    { 
     visited[i] = 1; 
     q.push(i); 
    } 
   } 
} 
}

int main() 
{ 
GT_BFS();//输出结果为1 2 5 3 4 9 7 6 8 10 
system("pause"); 
return 0; 
}

      2.有权最短路径,Dijkstra

/////////////////////////////////////////// 
//广度优先搜索之有权最短路径，Dijkstra算法 
// 1---(1)-->5 
// |     | 
//(2)      (12) 
// |        | 
// 2--(13)---4---(2)--6--(2)--8 
// |                  | 
//(4)               (5) 
// |                 | 
// 3----(1)----------7 
// 1 2 3 4 5 6 7 8 
//1 0 2 0 0 1 0 0 0 
//2 2 0 4 7 0 0 0 0 
//3 0 4 0 0 0 0 1 0 
//4 0 7 0 0 12 2 0 0 
//5 1 0 0 12 0 0 0 0 
//6 0 0 0 2 0 0 5 2 
//7 0 0 1 0 0 5 0 0 
//8 0 0 0 0 0 2 0 0

#include 
#include 
using namespace std;

//节点数 
#define M 8

//图的矩阵表示 
int matrix[M][M] = 
{ 0, 2, 0, 0, 1, 0, 0, 0, 
2, 0, 4, 13, 0, 0, 0, 0, 
0, 4, 0, 0, 0, 0, 1, 0, 
0, 13, 0, 0, 12, 2, 0, 0, 
1, 0, 0, 12, 0, 0, 0, 0, 
0, 0, 0, 2, 0, 0, 5, 2, 
0, 0, 1, 0, 0, 5, 0, 0, 
0, 0, 0, 0, 0, 2, 0, 0

};

//保存每个节点的最短路径,初始化为0xFFFF 
int dist[M + 1] ={0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF}; 
//calculate the distance 
void Dijkstra_BFS(int startNodeNum) 
{ 
dist[startNodeNum] = 0; 
queue q; 
q.push(startNodeNum); 
while(!q.empty()) 
{ 
   int top = q.front(); 
   q.pop(); 
   cout<   int i ; 
   for(i = 1; i <= M; ++i) 
   { 
    if(matrix[top - 1][i - 1 ] != 0 && (dist[top] + matrix[top - 1][i -1]) < dist[i] ) 
    { 
     dist[i] = dist[top] + matrix[top - 1][i -1]; 
     q.push(i); 
    } 
   } 
} 
} 
void PrintDist() 
{

for(int i = 1; i <= M; ++i) 
   cout<}

int main() 
{ 
Dijkstra_BFS(1); 
PrintDist(); 
system("pause"); 
return 0; 
}