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、DFS算法实现

//TODO

【数据结构与算法】自己动手实现图的BFS和DFS(附完整源码)

本文的重点在于图的深度优先搜索(DFS)和广度优先搜索(BFS),因此不再对图的基本概念做过多的介绍,但是要先大致了解下图的几种常见的存储结构。 邻接矩阵既可以用来存储无向图,也可以用来存储有...

关于图的广度优先搜索(BFS)和深度优先搜索(DFS)

前言:图的广度优先搜索和深度优先搜索对于获取图的结构信息具有重要的作用,很多图相关的算法都是建立在对图的结构进行搜索的基础上。如最小生成树算法、Dijkstra最短路径算法都采用了和BFS相似的思想。...

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

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

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

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

BFS广度优先搜索——入门

BFS——广度优先搜索 广度优先搜索是通过对图的完全遍历来达到要求的点的算法。其对图的遍历是如同波浪一样,每层按照制定的方式一层一层向下搜。 如: 5 5 4 2 ...
  • ilblue
  • ilblue
  • 2016年10月26日 21:03
  • 1217

BFS算法介绍

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

BFS、双向BFS和A*

BFS、双向BFS和A* Table of Contents 1. BFS2. 双向BFS3. A*算法 光说不练是没用的,我们从广为人知的POJ 2243这道题谈起:题目大...

经典算法研究系列:四、教你通透彻底理解:BFS和DFS优先搜索算法

4、教你通透彻底理解:BFS和DFS优先搜索算法  作者:July  二零一一年一月一日---------------------------------本人参考:算法导论 本人声明:个人原创,转载请...
  • v_JULY_v
  • v_JULY_v
  • 2011年01月01日 12:18
  • 92964

深度优先算法和广度优先算法

今天做了daoti
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:BFS-广度优先搜索算法(图)
举报原因:
原因补充:

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