BFS-广度优先搜索算法(图)

原创 2010年05月07日 20:54:00

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

特性

 

空间复杂度

因为所有节点都必须被储存,因此BFS的空间复杂度为 O(|V| + |E|),其中 |V| 是节点的数目,而 |E| 是图中边的数目。注:另一种说法称BFS的空间复杂度为 O(BM),其中 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;
}

【算法入门】广度/宽度优先搜索(BFS)

广度/宽度优先搜索(BFS) 【算法入门】 郭志伟@SYSU:raphealguo(at)qq.com 2012/04/27 1.前言 广度优先搜索(也称宽度优先搜索,缩写BFS,以下采用广...
  • raphealguo
  • raphealguo
  • 2012年04月30日 02:58
  • 67808

BFS和DFS算法原理(通俗易懂版)

DFS 算法 思想:一直往深处走,直到找到解或者走不下去为止 BFS算法 DFS:使用栈保存未被检测的结点,结点按照深度优先的次序被访问并依次被压入栈中,并以相反的次序出栈进行新的检测。...
  • u011437229
  • u011437229
  • 2016年11月16日 17:25
  • 19396

BFS算法介绍

定义: 广度优先算法(Breadth-First-Search),简称BFS,是一种图形搜索演算法。简单的说,BFS是从根节点开始,沿着树的宽度遍历树的节点,如果发现目标,则演算终止。 算法分析...
  • Geecky
  • Geecky
  • 2016年07月08日 19:44
  • 1666

图的搜索(bfs)

一般解决最短路程,最少步数的时候用bfs,bfs用到队列(先进先出),进行一层一层的搜索,其实bfs之所以能更好的解决最短路问题我觉得就是因为他是一层一层的去搜索。比如,他是先把第一步能走到的格子都入...
  • ly59782
  • ly59782
  • 2016年03月30日 14:15
  • 351

bfs详解

转自:http://www.2cto.com/kf/201605/509249.html                   广度/宽度优先搜索(BFS)详解                ...
  • qq_35323001
  • qq_35323001
  • 2016年09月07日 09:34
  • 1157

BFS学习总结

BFS学习总结          给你一个n*m的网格迷宫,迷宫中有些格子不能走,其他的格子都能走。然后给你起点与终点,问你从起点走到终点最少需要多少步?          上面的问题就是一个典型的B...
  • u013480600
  • u013480600
  • 2015年04月15日 23:53
  • 2073

BFS 搜索 写代码思路(顺序)

#include #include using namespace std; queue qu; void bfs() { while(!qu.empty())//只要队列不为空就往下搜...
  • HYNUHuangHao
  • HYNUHuangHao
  • 2016年08月15日 21:15
  • 581

BFS 基础

做一道题复习一下BFS迷宫=http://hncu.acmclub.com/index.php?app=problem_title&id=111&problem_id=1102 题目描述 小明置身...
  • iboxty
  • iboxty
  • 2015年05月21日 10:58
  • 1123

广度优先搜索BFS——图邻接表表示

BFS是图的另一个重要算法,下面是基于邻接表表示的BFS算法。 /* 图邻接表表示BFS input: 1 7 A 1 5 B 2 4 3 C 2 4 2 D 3 6 5 2 E 3 7 4 1 F...
  • that163
  • that163
  • 2012年10月07日 15:21
  • 1735

图dfs和bfs时的时间复杂度

下图摘自严蔚敏的教材: 上面说的是DFS。 下面说的是BFS。
  • wusecaiyun
  • wusecaiyun
  • 2015年11月01日 21:32
  • 7059
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:BFS-广度优先搜索算法(图)
举报原因:
原因补充:

(最多只允许输入30个字)