数据结构----BFS和DFS详解

最新推荐文章于 2024-01-24 11:24:14 发布
最新推荐文章于 2024-01-24 11:24:14 发布
阅读量2.5w 收藏 87
点赞数 23
分类专栏： 数据结构 文章标签： 数据结构 dfs 算法 BFS 图
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35644234/article/details/52518585
版权

前言
The art of teaching is the art of assisting discovery.
Name:Willam
Time:2017/2/28

这篇博客将会介绍两种遍历图的算法，一种是：DFS—-深度优先搜索，另外一种就是：BFS–广度优先搜索。

1、DFS （深度优先搜索）

算法思路：
从顶点V开始，访问这个顶点，然后依次从V的未被访问的邻接点出发深度优先遍历图，直至图中所有和V有路径的相通的顶点都被访问了，如果此时还有顶点未被访问，则选择图中未被访问的那个顶点作为起点，重复上述动作。

具体的代码实现如下：

#include<iostream>
#include<string>
using namespace std;

//使用邻接矩阵完成图的遍历
struct Graph_array {
    int vexnum;  //图的顶点数
    int edge;    //图的边数
    int ** arc;  //邻接矩阵
    int kind;    //0,为有向图，1，为无向图
    string * infromation; //表示每个顶点的信息

};
//使用邻接矩阵表示的图
void createGraph_by_array(int **edge,Graph_array & g) {
    int i = 0;
    g.arc = new int*[g.vexnum];//为邻接矩阵开辟空间
    for (i = 0; i < g.vexnum; i++)
    {
        g.arc[i] = new int[g.vexnum];
        for (int j = 0; j < g.vexnum; j++)
            g.arc[i][j] = 0;
    }   
    for (i = 0; i < g.edge; i++)
    {
        //对矩阵进行赋值
        g.arc[edge[i][0] - 1][edge[i][1] - 1] = 1;
    }
}
//打印邻接矩阵
void print_array(Graph_array g) {

    int i = 0;
    for (i = 0; i <g.vexnum; i++) {
        //cout << g.infromation[i] << " ";
        for (int j = 0; j < g.vexnum; j++) {
            cout << g.arc[i][j] << " ";
        }
        cout << endl;
    }
}
//进行DFS遍历，
void DFS_store_array(Graph_array g,int v,bool * & visit) {
    cout << g.infromation[v] << " ";
    visit[v] = true;
    for (int i = 0; i < g.vexnum; i++) {//找出下一个位被访问的顶点
        if (g.arc[v][i] == 0 || g.arc[v][i] == INT_MAX) { //如果两个顶点不存在边
            continue;
        }
        else if (!visit[i]) {//如果没有被访问，访问该结点
            DFS_store_array(g, i, visit);
        }
    }
}
//调用对应的DFS函数进行图的遍历
void DFS_array_travel(Graph_array g,int begin) {
    bool * visit;
    visit = new bool[g.vexnum];
    int i;
    for (i = 0; i < g.vexnum; i++) {
        visit[i] = false;
    }
    cout << "图的DFS遍历结果：" << endl;
    DFS_store_array(g,begin - 1,visit);
    //如果图是非联通同，那么我们这里还需要对每个顶点遍历一次，保证
    //全部顶点都被访问了
    for (i = 0; i < g.vexnum; i++) {
        if (!visit[i])
            DFS_store_array(g, i,visit);
    }

}

//使用邻接表表示图进行图的遍历
//表结点
struct ArcNode {
    int adfvex;//表示该边的另外一个顶点在顶点表中的下标
    ArcNode * next; //表示依附在该顶点的下一条边的信息
};
//头结点
struct Vnode {
    string data; //记录基本信息i
    ArcNode * firstarc;//记录第一条依附在该顶点的边
};
//一个图的结构
struct Graph_List {
    int vexnum;  //图的顶点数
    int edge;    //图的边数
    Vnode * node;  //邻接表
    int kind;    //0,为有向图，1，为无向图
};
//建立邻接表
void createGraph_list(Graph_List & g, int **edge) {
    int i;
    for (i = 0; i < g.edge; i++)
    {
        ArcNode * next=new ArcNode;
        next->adfvex=edge[i][1]-1;
        next->next = NULL;
        //判断该顶点的是否已经有边依附
        if (g.node[edge[i][0]-1].firstarc == NULL) {
            g.node[edge[i][0]-1].firstarc = next;
        }
        else {//寻找链表的最后一个结点
            ArcNode * now;
            now = g.node[edge[i][0]-1].firstarc;
            while (now->next) {
                now = now->next; 
            }
            now->next = next;
        }
    }
}
//打印邻接表
void print_list(Graph_List g) {
    int i;
    for (i = 0; i < g.vexnum; i++) {
        cout << g.node[i].data << " ";
        ArcNode * now;
        now = g.node[i].firstarc;
        while (now) {
            cout << now->adfvex << " ";
            now = now->next;
        }
        cout << endl;
    }
}
//使用DFS进行遍历图，在邻接表的情况下进行遍历
void DFS_store_list(Graph_List g, int v, bool * & visit) {
    cout << g.node[v].data << " ";
    visit[v] = true;
    ArcNode * next = g.node[v].firstarc;
    while (next) {
        if (!visit[next->adfvex]) {
            DFS_store_list(g, next->adfvex, visit);//递归
        }
        else {
            next = next->next;
        }
    }
}
//调用上面那个函数进行图的遍历
void DFS_list(Graph_List g, int begin) {
    int i;
    bool * visit = new bool[g.vexnum];
    for (i = 0; i < g.vexnum; i++) {
        visit[i] = false;
    }
    cout << "图的DFS遍历结果：" << endl;
    DFS_store_list(g, begin - 1, visit);
    for (i = 0; i < g.vexnum; i++) {
        if(!visit[i])
            DFS_store_list(g, i, visit);
    }
}
int main()
{
    Graph_array g;
    Graph_List G;
    int i;
    cout << "输入图的种类：" << endl;
    cin >> g.kind; G.kind = g.kind;

    cout << "输入图的顶点个数" << endl;
    cin >> g.vexnum; G.vexnum = g.vexnum;

    cout << "输入图的边的个数（输入时注意，无向图的边要比看的边乘以2，然后输入的记得把重复的边也要输进去）" << endl;
    cin >> g.edge; G.edge = g.edge;

    g.infromation = new string[g.vexnum];
    G.node = new Vnode[G.vexnum];


    cout << "输入每个顶点信息（如名称）:" << endl;
    for (i = 0; i < g.vexnum; i++) {
        cin >> g.infromation[i];
        G.node[i].data = g.infromation[i];
        G.node[i].firstarc = NULL;
    }

    int ** edge_information;
    edge_information = new int*[g.edge];

    cout << "输入每条边两个顶点的编号：" << endl;
    for (i = 0; i < g.edge; i++)
    {
        edge_information[i] = new int[2];
        cin >> edge_information[i][0];
        cin >> edge_information[i][1];
    }

    int **arc; //邻接矩阵
    //构造邻接矩阵,其中最后一次参数：1，代表无向图，0，代表有向图
    createGraph_by_array(edge_information,g);
    cout << "图的邻接矩阵为：" << endl;
    print_array(g);
    cout << endl;
    DFS_array_travel(g, 1);
    cout << endl;

    createGraph_list(G, edge_information);
    cout << "图的邻接表为：" << endl;
    print_list(G);
    cout << endl;
    DFS_list(G, 1);
    cout << endl;
    system("pause");
    return 0;


}

下面，我们对如下这个图进行遍历，
这里写图片描述
使用上述程序，输出的结果为：
（输入时注意，无向图的边要比看的边乘以2，然后输入的记得把重复的边也要输进去）
这里写图片描述

2、BFS （广度优先搜索）

BFS就是我们所说的广度优先搜索，它的思路就是：假设从图中的顶点V出，在访问了v之后，依次访问v的各个未被访问的邻接点，然后，分别从这些邻接点出发，依次访问他们的邻接点，并使“先被访问的顶点的邻接点”先于“后被访问的邻接点”先被访问，直至图中所有的顶点都被访问到为止，防止出现非连通图的情况，我们需要最后遍历一遍，看是否所有的点都被访问了，如果有未被访问的点，那么就把该点作为一个新的起点。

代码实现如下：

#include<iostream>
#include<string>
#include<queue>
using namespace std;

//使用邻接矩阵完成图的遍历
struct Graph_array {
    int vexnum;  //图的顶点数
    int edge;    //图的边数
    int ** arc;  //邻接矩阵
    int kind;    //0,为有向图，1，为无向图
    string * infromation; //表示每个顶点的信息

};
//使用邻接矩阵表示的图
void createGraph_by_array(int **edge, Graph_array & g) {
    int i = 0;
    g.arc = new int*[g.vexnum];//为邻接矩阵开辟空间
    for (i = 0; i < g.vexnum; i++)
    {
        g.arc[i] = new int[g.vexnum];
        for (int j = 0; j < g.vexnum; j++)
            g.arc[i][j] = 0;
    }
    for (i = 0; i < g.edge; i++)
    {
        //对矩阵进行赋值
        g.arc[edge[i][0] - 1][edge[i][1] - 1] = 1;
    }
}
//打印邻接矩阵
void print_array(Graph_array g) {

    int i = 0;
    for (i = 0; i <g.vexnum; i++) {
        //cout << g.infromation[i] << " ";
        for (int j = 0; j < g.vexnum; j++) {
            cout << g.arc[i][j] << " ";
        }
        cout << endl;
    }
}

//调用对应的BFS函数进行图的遍历
void BFS_array_travel(Graph_array g, int begin) {
    bool * visit;
    visit = new bool[g.vexnum];
    int i;
    for (i = 0; i < g.vexnum; i++) {
        visit[i] = false;
    }
    cout << "图的BFS遍历结果：" << endl;
    //通过我们之前说的算法思路，我们可以知道
    //我们需要使用先进先出的数据存储结构实现我们的BFS，其实那就是队列
    queue<int>  q;
    for (int v = 0; v < g.vexnum; v++) {//这重循环是为了保证非连通同的情况下，每个顶点都可以被访问
        if (!visit[(begin-1 + v) % g.vexnum])//注意起点不一定是v1
        {
            cout << g.infromation[(begin - 1 + v) % g.vexnum] << " ";
            visit[(begin - 1 + v) % g.vexnum] = true;
            q.push((begin - 1 + v) % g.vexnum);//初始化我们的队列
            while (!q.empty())
            {
                int u = q.front();
                q.pop();
                for (int j = 0; j < g.vexnum; j++) {
                    if (g.arc[u][j] == 0 || g.arc[u][j] == INT_MAX) { //如果两个顶点不存在边
                        continue;
                    }
                    else if (!visit[j] ) {//先访问所有和u相连的顶点，并且把它们加入队列
                        cout << g.infromation[j] << " ";
                        visit[j] = true;
                        q.push(j);
                    }
                }
            }
        }

    }
    cout << "完成" << endl;

}

//使用邻接表表示图进行图的遍历
//表结点
struct ArcNode {
    int adfvex;//表示该边的另外一个顶点在顶点表中的下标
    ArcNode * next; //表示依附在该顶点的下一条边的信息
};
//头结点
struct Vnode {
    string data; //记录基本信息i
    ArcNode * firstarc;//记录第一条依附在该顶点的边
};
//一个图的结构
struct Graph_List {
    int vexnum;  //图的顶点数
    int edge;    //图的边数
    Vnode * node;  //邻接表
    int kind;    //0,为有向图，1，为无向图
};
//建立邻接表
void createGraph_list(Graph_List & g, int **edge) {
    int i;
    for (i = 0; i < g.edge; i++)
    {
        ArcNode * next = new ArcNode;
        next->adfvex = edge[i][1] - 1;
        next->next = NULL;
        //判断该顶点的是否已经有边依附
        if (g.node[edge[i][0] - 1].firstarc == NULL) {
            g.node[edge[i][0] - 1].firstarc = next;
        }
        else {//寻找链表的最后一个结点
            ArcNode * now;
            now = g.node[edge[i][0] - 1].firstarc;
            while (now->next) {
                now = now->next;
            }
            now->next = next;
        }
    }
}
//打印邻接表
void print_list(Graph_List g) {
    int i;
    for (i = 0; i < g.vexnum; i++) {
        cout << g.node[i].data << " ";
        ArcNode * now;
        now = g.node[i].firstarc;
        while (now) {
            cout << now->adfvex << " ";
            now = now->next;
        }
        cout << endl;
    }
}

//利用BFS进行图的遍历
void BFS_list(Graph_List g, int begin) {
    int i;
    bool * visit = new bool[g.vexnum];
    for (i = 0; i < g.vexnum; i++) {
        visit[i] = false;
    }
    cout << "图的BFS遍历结果：" << endl;
    queue<int>  q;
    for (int v = 0; v < g.vexnum; v++) {
        if (!visit[(begin - 1 + v) % g.vexnum])//注意起点不一定是v1
        {
            cout << g.node[(begin - 1 + v) % g.vexnum].data << " ";
            visit[(begin - 1 + v) % g.vexnum] = true;
            q.push((begin - 1 + v) % g.vexnum);//初始化我们的队列
            while (!q.empty())
            {
                int u = q.front();
                q.pop();
                ArcNode * next;
                next = g.node[u].firstarc;//获得依附在该顶点的第一条边的信息
                while (next) {//遍历该链表上的所有的点
                    if (!visit[next->adfvex]) {
                        cout << g.node[next->adfvex].data << " ";
                        visit[next->adfvex] = true;
                        q.push(next->adfvex);
                    }
                    next = next->next;
                }
            }
        }
    }
}
int main()
{
    Graph_array g;
    Graph_List G;
    int i;
    cout << "输入图的种类：" << endl;
    cin >> g.kind; G.kind = g.kind;

    cout << "输入图的顶点个数" << endl;
    cin >> g.vexnum; G.vexnum = g.vexnum;

    cout << "输入图的边的个数" << endl;
    cin >> g.edge; G.edge = g.edge;

    g.infromation = new string[g.vexnum];
    G.node = new Vnode[G.vexnum];


    cout << "输入每个顶点信息（如名称）:" << endl;
    for (i = 0; i < g.vexnum; i++) {
        cin >> g.infromation[i];
        G.node[i].data = g.infromation[i];
        G.node[i].firstarc = NULL;
    }

    int ** edge_information;
    edge_information = new int*[g.edge];

    cout << "输入每条边两个顶点的编号：" << endl;
    for (i = 0; i < g.edge; i++)
    {
        edge_information[i] = new int[2];
        cin >> edge_information[i][0];
        cin >> edge_information[i][1];
    }

    int **arc; //邻接矩阵
               //构造邻接矩阵,其中最后一次参数：1，代表无向图，0，代表有向图
    createGraph_by_array(edge_information, g);
    cout << "图的邻接矩阵为：" << endl;
    print_array(g);
    cout << endl;
    BFS_array_travel(g, 1);
    cout << endl;

    createGraph_list(G, edge_information);
    cout << "图的邻接表为：" << endl;
    print_list(G);
    cout << endl;
    BFS_list(G, 1);
    cout << endl;
    system("pause");
    return 0;


}

同样是对DFS遍历的那个图进行遍历，结果如下：
这里写图片描述

3、总结

上述我们采用两种方式对图进行的了遍历包括了两种表达方式：邻接表和邻接矩阵，首先我们看遍历的方法上的选择，其实这两种遍历算法的时间复杂度是一样的，它们的不同就是在于遍历顶点的顺序不同，另外，对于两种图的不同的表示方式，我们可以发现邻接矩阵的表示下，图遍历的时间复杂度为：o（n*n），而在邻接表的下，遍历的时间复杂度只是：O(n+e),其中n为顶点个数，e为边的条数，所以，在实际中需要进行图的遍历的情况下，我们最好是采用邻接表的方式进行表示我们的图。

Ouyang_Lianjun
关注
  • 23
    点赞
  • 踩
  • 87
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构-DFS and BFS-PPT
02-04
数据结构-DFS and BFS-PPT
数据结构——图的广度优先遍历（BFS）
huaimaisui的博客
07-23 3971
本文内图的存储方式是邻接矩阵，不过BFS的具体实现代码与图的存储结构无关。
G1垃圾回收器
最新发布
weixin_50247953的博客
01-24 1255
G1垃圾回收器详解
dfs与bfs的简单总结及应用 | 详解
一只酷酷光儿的博客
03-02 5万+
写了三个小时的总结
C++数据结构与算法分析——BFS(宽度优先遍历)
l_red_forest的博客
09-13 2505
BFS 介绍 BFS也叫宽度优先遍历，广度优先遍历，宽度优先搜索，广度优先搜索，是一种常用的搜索手段。
数据结构与算法——深度优先搜索（DFS）
weixin_38938338的博客
12-28 2244
深度优先搜索（DFS）算法总结 1.介绍 深度优先搜索属于图算法的一种，是一个针对图和树的遍历算法，英文缩写为DFS即Depth First Search。深度优先搜索是图论中的经典算法，利用深度优先搜索算法可以产生目标图的相应拓扑排序表，利用拓扑排序表可以方便的解决很多相关的图论问题，如最大路径问题等等。一般用堆数据结构来辅助实现DFS算法。其过程简要来说是对每一个可能的分支路径深入到不能再深入...
数据结构篇（三）：DFS和BFS算法的分析与总结之BFS篇
qq_52528413的博客
09-17 914
前言： 广度优先遍历（Breath First Search）作为一种相对DFS算法来说，更加适合迷宫算法的算法，尤其在最短路径求解时有着自己独特的用法；其实将BFS和DFS放到一起来看，其实不管是BFS换上DFS，都是对线性表的操作，只不过DFS是利用栈的特性写的回溯函数而已，而BFS是利用队列的特性写的拓展函数而已。 （不是很懂DFS算法的兄弟们可以看我上一篇博客） https://blog.csdn.net/qq_52528413/article/details/120241993?spm=10
力扣刷题系列——BFS和DFS
qq_43568704的博客
08-25 1919
BFS与DFS相关算法题 BFS 广度优先搜索（也称宽度优先搜索，缩写BFS，以下采用广度来描述）是连通图的一种遍历算法这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。基本过程，BFS是从根节点开始，沿着树(图)的宽度遍历树(图)的节点。如果所有节点均被访问，则算法中
DFS和BFS的简单理解和使用
yygr的博客
06-02 345
https://www.jianshu.com/p/fbe0d05187a5首先这两个概念应该都是算法上的，这个没啥疑问。 先用官方的说法说一下两者的区别：DFS（Deep First Search）深度优先搜索。BFS（Breath First Search）广度优先搜索。至于说所谓的深度和广度，让我们用"人话"来理解一下：什么是DFS深度优先搜索？用一个常用的思路来表述：递归就是一个标准的深度搜索。一层一层往下走。但是有些时候在算法中经常会遇到一条路走不通的情况，那么我们就返回上一层换条路走。 拿一个游
数据结构与算法—图论之dfs、bfs(深度优先搜索、宽度优先搜索)
bigsai
09-05 6971
文章目录前言深度优先搜索(dfs) 前言 在有向图和无向图中，如果节点之间无权值或者权值相等，那么dfs和bfs时常出现在日常算法中。不仅如此，dfs，bfs不仅仅能够解决图论的问题，在其他问题的搜索上也是最基础(但是策略不同)的两种经典算法。 并且五大经典算法的回溯算法其实也是dfs的一种。dfs,bfs基础能够解决搜索类问题的大部分情况，只不过搜索随着数据增大而呈非线性的增长，所以两种算法在...
宽度优先搜索算法（BFS）详解（超级详细讲解，附有大图）
aliyonghang的博客
01-18 3万+
​ 补充说明：由上可以知道，广度优先搜索的特征为从起点开始，由近及远进行广泛的搜索。因此，目标顶点离起点越近，搜索结束得就越快。 三.对比与发现 DFS和BFS的区别 bfs 遍历节点是先进先出，dfs遍历节点是先进后出； bfs是按层次访问的，dfs 是按照一个路径一直访问到底，当前节点没有未访问的邻居节点时，然后回溯到上一个节点，不断的尝试，直到访问到目标节点或所有节点都已访问。 bfs 适用于求源点与目标节点距离最近的情况，例如：求最短路径。dfs 更适合于求解一个任意符合方案中的一个或者遍历所有情
dfs-bfs-master.zip_bfs_dfs
09-24
dfs-bfs-master 网上找到的 dfs和bfs演示
dfs_bfs.rar_C-C++_bfs
09-23
a program to find Dfs and bfs
leetcode池塘-DSA-BFS-DFS:DSA-BFS-DFS
06-30
网友DSA-BFS-DFS 广度优先搜索（BFS）和广度优先遍历 广度优先搜索 (BFS)是一种探索树或图的方法。 在 BFS 中，您首先探索一步之外的所有节点，然后探索两步之外的所有节点，依此类推。 广度优先搜索就像在池塘中央...
Bfs-Dfs.rar_bfs
09-21
在C环境中使用Bfs，Dfs的遍历算法创建邻接表建立图。
最短路径问题---Dijkstra算法详解
热门推荐
William
03-08 82万+
前言 Nobody can go back and start a new beginning,but anyone can start today and make a new ending. Name:Willam Time:2017/3/8 1、最短路径问题介绍 问题解释： 从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径，称为最短路径 解决问题的算法：...
最短路径问题---Floyd算法详解
William
03-11 29万+
前言 Genius only means hard-working all one’s life. Name:Willam Time:2017/3/81、最短路径问题介绍问题解释： 从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径，称为最短路径解决问题的算法： 迪杰斯特拉算法（Dijkstra算法） 弗洛伊德算法（Floyd算法） SPFA算法 之前已经对Di
数据结构--最小生成树详解
William
03-03 19万+
前言 A wise man changes his mind,a fool never. Name:Willam Time:2017/3/11、什么是最小生成树现在假设有一个很实际的问题：我们要在n个城市中建立一个通信网络，则连通这n个城市需要布置n-1一条通信线路，这个时候我们需要考虑如何在成本最低的情况下建立这个通信网？ 于是我们就可以引入连通图来解决我们遇到的问题，n个城市就是图上的n
数据结构--链表的排序详解
William
11-18 11万+
1、前言 前面两篇博客，我已经把线性表的两种基本的表示形式，做了一个基本的介绍和一些对比。但是，我突然发现在链表这里我缺少一个很重要的内容，那就是对我们的链表进行排序，其实，在连接两个链表的时候，就要求我们的那两个链表是有序的。2、链表排序—最简单、直接的方式（直接采用冒泡或者选择排序，而且不是交换结点，只交换数据域）//线性表的排序,采用冒泡排序,直接遍历链表 void Listsort(Nod
数据结构与算法 - 队列
09-12
你好！队列（Queue）是一种先进先出（FIFO）的数据结构，类似于现实生活中排队的概念。它有两个基本操作：入队（enqueue）和出队（dequeue）。 入队操作将元素添加到队列的末尾，出队操作则从队列的头部移除元素并返回它。这样就保证了先入队的元素先出队，实现了先进先出的特性。 队列的另一个重要操作是获取队列头部元素，但不移除它。这个操作通常称为查看头部元素（peek）。 使用队列可以解决很多实际问题，比如任务调度、缓冲区管理等。它还被广泛应用在算法中，例如广度优先搜索（BFS）等。 如果你对具体的队列实现或者其他相关算法有更多问题，我会很乐意帮助你。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值