数据结构7——BFS

一、重拾关键

宽度优先搜索,也有称为广度优先搜索,简称BFS。类似于树的按层次遍历的过程。

初始状态:图G所有顶点均未被访问过,任选一点v。

遍历过程:假设从图中某顶点v出发,在访问了v之后依次访问v的各个未曾访问过的邻接点,然后分别从这些邻接点出发依次访问它们的邻接点,并使“先被访问的顶点的邻接点”先于“后被访问的顶点的邻接点”被访问,直至图中所有已被访问的顶点的邻接点都被访问到。若此时图中尚有顶点未被访问,则另选图中一个未曾被访问的顶点作起始点,重复上述过程,直至图中所有顶点都被访问到为止。换句话说,广度优先搜索遍历图的过程中以v为起始点,由近至远,依次访问和v有路径相通且路径长度为1,2,…的顶点。

二、算法过程

以如下图的无向图G4为例,进行图的宽度优先搜索:

假设从顶点v1出发进行搜索,首先访问v1和v1的邻接点v2和v3,然后依次访问v2的邻接点v4和v5及v3的邻接点v6和v7,最后访问v4的邻接点v8。由于这些顶点的邻接点均已被访问,并且图中所有顶点都被访问,由些完成了图的遍历。得到的顶点访问序列为:

和深度优先搜索类似,在遍历的过程中也需要一个访问标志数组。并且,为了顺次访问路径长度为2、3、…的顶点,需附设队列以存储已被访问的路径长度为1、2、… 的顶点。

三、代码实现

邻接矩阵做存储结构时,广度优先搜索的代码如下。

/*    图的BFS遍历    */
//邻接矩阵形式实现
//顶点从1开始
#include<iostream>
#include<cstdio>
#include<queue>
using namespace std;
const int maxn = 105;        //最大顶点数
typedef int VertexType;     //顶点类型
bool vis[maxn];  

struct Graph{               //邻接矩阵表示的图结构
    VertexType vex[maxn];   //存储顶点
    int arc[maxn][maxn];    //邻接矩阵
    int vexnum,arcnum;      //图的当前顶点数和弧数
};

void createGraph(Graph &g)  //构建有向网g
{
    cout<<"请输入顶点数和边数:";
    cin>>g.vexnum>>g.arcnum;

    //构造顶点向量
    cout<<"请依次输入各顶点:\n";
    for(int i=1;i<=g.vexnum;i++){
        scanf("%d",&g.vex[i]);
    }

    //初始化邻接矩阵
    for(int i=1;i<=g.vexnum;i++){
        for(int j=1;j<=g.vexnum;j++){
            g.arc[i][j] = 0;
        }
    }

    //构造邻接矩阵
    VertexType u,v;     //分别是一条弧的弧尾(起点)和弧头(终点)
    printf("每一行输入一条弧依附的顶点(空格分开):\n");
    for(int i=1;i<=g.arcnum;i++){
        cin>>u>>v;
        g.arc[u][v] = g.arc[v][u] = 1;
    }
}

//邻接矩阵的宽度遍历操作
void BFSTraverse(Graph g)
{
    queue<int> q;                        //声明队列q
    for(int i=1;i<=g.vexnum;i++){
        vis[i] = false;
    }
    for(int i=1;i<=g.vexnum;i++){        //对每个顶点做循环
        if(!vis[i]){
            vis[i] = true;
            printf("%d\t",g.vex[i]);
            q.push(i);                    //将此节点入队列
            while(!q.empty()){
                int m = q.front();
                q.pop();                //出队列,值已赋给m
                for(int j=1;j<=g.vexnum;j++){
                    if(g.arc[m][j]==1 && !vis[j]){        //如果顶点j是顶点i的未访问的邻接点
                        vis[j] = true;
                        printf("%d\t",g.vex[j]);
                        q.push(j);                        //将顶点j入队列
                    }
                }

            }
        }
    }

} 

int main()
{
    Graph g;
    createGraph(g);
    BFSTraverse(g);
    return 0;
}

对于邻接表的广度优先遍历,代码与邻接矩阵差异不大, 代码如下。

//邻接表的广度遍历算法
void BFSTraverse(GraphList g)
{
    int i;
    EdgeNode *p;
    Queue q;
    for(i = 0; i < g.numVertexes; i++)
    {
        visited[i] = FALSE;
    }
    InitQueue(&q);
    for(i = 0; i < g.numVertexes; i++)
    {
        if(!visited[i])
        {
            visited[i] = TRUE;
            printf("%c ", g.adjList[i].data);   //打印顶点,也可以其他操作
            EnQueue(&q, i);
            while(!QueueEmpty(q))
            {
                int m;
                DeQueue(&q, &m);
                p = g.adjList[m].firstedge;     找到当前顶点边表链表头指针
                while(p)
                {
                    if(!visited[p->adjvex])
                    {
                        visited[p->adjvex] = TRUE;
                        printf("%c ", g.adjList[p->adjvex].data);
                        EnQueue(&q, p->adjvex);
                    }
                    p = p->next;
                }
            }
        }
    }
}

分析上述算法,每个顶点至多进一次队列。遍历图的过程实质是通过边或弧找邻接点的过程,因此广度优先搜索遍历图的时间复杂度和深度优先搜索遍历相同,两者不同之处仅仅在于对顶点访问的顺序不同。

四、沙场练兵

题目一、迷宫问题

时间: 2024-10-02 23:56:25

数据结构7——BFS的相关文章

数据结构之bfs

宽度优先搜索算法(又称广度优先搜索)是最简便的图的搜索算法之一,这一算法也是很多重要的图的算法的原型.Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想. poj3278 思路:根节点n,        n+1,n-1,2*n三个子节点不断地延伸,目标节点k,寻找这样一天最短的路 代码: #include <iostream>#include <stdio.h>#include <string.h>#include <stdl

Uva 1599 最佳路径

题目链接:https://uva.onlinejudge.org/external/15/1599.pdf 题意: 保证在最短路的时候,输出字典序最小的路径. 方法: 路径上有了权值,可以利用图论的数据结构来BFS,很方便. 逆序BFS,找到每个点距离终点的最短路长 d[x] ; 然后,从起点,沿着 d[u] = d[v] + 1; 的路径,分层BFS,选字典序最小的.找到那个最小字典序的节点之后,从新建队列.直到找完 d[0]; #include <bits/stdc++.h> using

数据结构学习笔记05图 (邻接矩阵 邻接表--&gt;BFS DFS)

数据结构之图 图(Graph) 包含 一组顶点:通常用V (Vertex) 表示顶点集合 一组边:通常用E (Edge) 表示边的集合 边是顶点对:(v, w) ∈E ,其中v, w ∈ V 有向边<v, w> 表示从v指向w的边(单行线) 不考虑重边和自回路 无向图:边是无向边(v, w) 有向图:边是有向边<v, w> 连通:如果从V到W存在一条(无向)路径,则称V和W是连通的 连通图(Connected Graph):如果对于图的任一两个顶点v.w∈V,v和w都是连通的,则称

数据结构:树的BFS,树的层次遍历! 按先序遍历创建一棵树,然后以层次遍历输出。

按先序遍历创建一棵树,以层次遍历输出 样例输入 A B # D # # C E # # F # # 样例输出 LevelOrder: A B C D E F 代码: #include <iostream> #include <queue> using namespace std; struct node { //表示一个树上的节点 char ch; node *left, *right; }; node* creat() { //以递归的方式构造一棵二叉树 node *root =

ACM/ICPC 之 数据结构-邻接表+BFS(TshingHua OJ-无线广播Broadcast)

这道题中若能够构成互不干扰的区域,其构成的图其实就是汉密尔顿路(Hamilton road),因此如果能够观察出来可以直接转化为汉密尔顿路的存在性证明,即便不能观察,我相信ACMer也能转化为BFS问题,这道题是一道很好的图论问题,对考察自己图论的基本功很有帮助. 无线广播(Broadcast) 描述 某广播公司要在一个地区架设无线广播发射装置.该地区共有n个小镇,每个小镇都要安装一台发射机并播放各自的节目. 不过,该公司只获得了FM104.2和FM98.6两个波段的授权,而使用同一波段的发射机

数据结构之 图论---基于邻接矩阵的广度优先搜索遍历(输出bfs遍历序列)

数据结构实验图论一:基于邻接矩阵的广度优先搜索遍历 Time Limit: 1000MS Memory limit: 65536K 题目描述 给定一个无向连通图,顶点编号从0到n-1,用广度优先搜索(BFS)遍历,输出从某个顶点出发的遍历序列.(同一个结点的同层邻接点,节点编号小的优先遍历) 输入 输入第一行为整数n(0< n <100),表示数据的组数. 对于每组数据,第一行是三个整数k,m,t(0<k<100,0<m<(k-1)*k/2,0< t<k),

数据结构之 图论---bfs(邻接表)

数据结构实验之图论二:基于邻接表的广度优先搜索遍历 Time Limit: 1000MS Memory limit: 65536K 题目描述 给定一个无向连通图,顶点编号从0到n-1,用广度优先搜索(BFS)遍历,输出从某个顶点出发的遍历序列.(同一个结点的同层邻接点,节点编号小的优先遍历) 输入 输入第一行为整数n(0< n <100),表示数据的组数. 对于每组数据,第一行是三个整数k,m,t(0<k<100,0<m<(k-1)*k/2,0< t<k),

图的BFS和DFS在数据结构为邻接矩阵时的实现

#include <iostream> #include <queue> using namespace std; //因为只是为了练习DFS和BFS 数据结构定义的很随意 没有优化类啦 能用就行 class Graph { private: static const int MAX=100; int weight[MAX][MAX];//任意一个图最大节点数为MA int nodes; int vertexs; bool *isVisited; public: void init

(编程训练)再回首,数据结构——无向图的邻接矩阵表示、DFS、BFS

最近在复习数据结构,顺便看看大一的时候写的代码,看完之后比当初有了更加深刻的体会. 希望这些能提供给初学者一些参考. 在VC++6.0下可运行,当初还写了不少注释. [问题描述] 建立图的邻接矩阵存储结构,实现图的遍历 [基本要求] ·功能:建立图的邻接矩阵存储结构,实现图的BFS.DFS ·输入:输入连通图的顶点数.顶点信息.边数.顶点对序列及遍历的起始顶点序号 ·输出:图的广度优先搜索序列.深度优先搜索 [模块划分] 1. 建立有向图的邻接表 CreateAdjMatrix() 2. 以邻接