图的BFS和DFS原理及实例分析（java） & 转载 图的DFS和BFS算法

最新推荐文章于 2024-04-24 17:48:12 发布
最新推荐文章于 2024-04-24 17:48:12 发布
阅读量392 收藏 3
点赞数
分类专栏： jv

图的BFS和DFS原理及实例分析（java）

https://blog.csdn.net/feilong_csdn/article/details/69386527

图的深度优先遍历(DFS)和广度优先遍历(BFS），DFS利用递归来实现比较易懂，DFS非递归就是将需要的递归的元素利用一个栈Stack来实现，以达到递归时候的顺序，而BFS则是利用一个队列Queue来实现。

package DataStructure;

import java.util.LinkedList;  
import java.util.Queue;  
import java.util.Stack;

public class Graph {   
    private int number = 9;  
    private boolean[] flag;  
    private String[] vertexs = { "A", "B", "C", "D", "E", "F", "G", "H", "I" };  
    private int[][] edges = {   
            { 0, 1, 0, 0, 0, 1, 1, 0, 0 }, 
            { 1, 0, 1, 0, 0, 0, 1, 0, 1 }, 
            { 0, 1, 0, 1, 0, 0, 0, 0, 1 },  
            { 0, 0, 1, 0, 1, 0, 1, 1, 1 }, 
            { 0, 0, 0, 1, 0, 1, 0, 1, 0 }, 
            { 1, 0, 0, 0, 1, 0, 1, 0, 0 },  
            { 0, 1, 0, 1, 0, 1, 0, 1, 0 }, 
            { 0, 0, 0, 1, 1, 0, 1, 0, 0 }, 
            { 0, 1, 1, 1, 0, 0, 0, 0, 0 }   
            };  

    void DFSTraverse() {  
        flag = new boolean[number];  
        for (int i = 0; i < number; i++) {  
            if (flag[i] == false) {// 当前顶点没有被访问  
                DFS(i);  
            }  
        }  
    }  

    void DFS(int i) {  
        flag[i] = true;// 第i个顶点被访问  
        System.out.print(vertexs[i] + " ");  
        for (int j = 0; j < number; j++) {  
            if (flag[j] == false && edges[i][j] == 1) {  
                DFS(j);  
            }  
        }  
    }  

    void DFS_Map(){
        flag = new boolean[number];
        Stack<Integer> stack =new Stack<Integer>();
        for(int i=0;i<number;i++){
            if(flag[i]==false){
                flag[i]=true;
                System.out.print(vertexs[i]+" ");
                stack.push(i);
            }
            while(!stack.isEmpty()){
                int k = stack.pop();
                for(int j=0;j<number;j++){
                    if(edges[k][j]==1&&flag[j]==false){
                        flag[j]=true;
                        System.out.print(vertexs[j]+" ");
                        stack.push(j);
                        break;
                    }
                }

            }
        }
    }

    void BFS_Map(){
        flag = new boolean[number];
        Queue<Integer> queue = new LinkedList<Integer>();
        for(int i=0;i<number;i++){
            if(flag[i]==false){
                flag[i]=true;
                System.out.print(vertexs[i]+" ");
                queue.add(i);
                while(!queue.isEmpty()){
                    int k=queue.poll();
                    for(int j=0;j<number;j++){
                        if(edges[k][j]==1&&flag[j]==false){
                            flag[j] = true;
                            System.out.print(vertexs[j]+" ");
                            queue.add(j);
                        }
                    }
                }
            }
        }
    }

    public static void main(String[] args) {  
        Graph graph = new Graph();  
        System.out.println("DFS递归:");  
        graph.DFSTraverse();
        System.out.println();
        System.out.println("DFS非递归:");  
        graph.DFS_Map();
        System.out.println();  
        System.out.println("BFS非递归:");  
        graph.BFS_Map();
    }  
} 
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99

程序运行结果：
这里写图片描述

前言

图的DFS和BFS算法
https://blog.csdn.net/qq_24486393/article/details/50270481

文章主要介绍数据结构知识板块中图的两种不同存储结构下（邻接表和邻接矩阵）BFS和DFS遍历算法。BFS和DFS应用领域不再说明，深搜和广搜的遍历算法十分重要。

DFS

原理：深度优先搜索，顾名思义即为一条道走到黑的搜索策略，行不通退回来换另外一条道再走到黑，依次直到搜索完成。其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次。可以通过图示清晰的说明。

图解遍历下图的全部节点：
这里写图片描述

基于邻接矩阵的DFS算法代码实现

void DFS(GraphAMatrix G,int i,int *visited)
{
    int j;
    if(visited[i])
        return ;//若结点被遍历过 返回 
    else
    {
        cout<<i<<endl;
        visited[i]=1;
        //遍历与该结点相邻的结点 (从第一个开始) 
        for(j=0;j<G.numVertexs;j++)
        {
            if(!visited[i]&&G.Edge[i][j])
                DFS(G,j,visited);//从相邻结点的第一个进行递归式深搜遍历 
        }
    }
} 
void DFS_GreahDG(GreapAMstrix G)
{
    int i,j,e;
    int *visited;//为每一个结点设置一个初始标志为未遍历 
    visited=(int *)malloc(sizeof(int)*G.numVertexs);
    memset(visited,0,sizeof(int)*G.numVertexs);
    //对每一个未被遍历结点进行DFS深度搜索 
    for(i=0;i<G.numVertexs;i++)
    {
        if(!visited[i])
            DFS(G,i,visited);//调用深搜算法 
    }
    free(visited);//释放指针 
    printf("\n");
} 
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

基于邻接表的DFS算法实现（全）

#include<iostream>
#include<stdlib.h>
#define maxvn 10

using namespace std;
typedef char VertexType;

//定义图的存储数据类型 
typedef struct ArcNode{
    int adjvesx;
    struct ArcNode *nextarc;
    int info;
}ArcNode;
typedef struct VNode{
    VertexType data;
    ArcNode *firstarc; 
}VNode,AdjList[maxvn];
typedef struct{
    AdjList vertices;
    int Vnum,Anum;
}AdjGraph;

//定义一个全局标识数组 
int visited[maxvn];

int LocateVex(char u,AdjGraph G)
{
    int i;
    for(i=0;i<G.Vnum;i++)
    {
        if(u==G.vertices[i].data)
            return i;
    }
    if(i==G.Vnum)
    {
        cout<<"ERROR!"<<endl;
        exit(1); 
    }
    return 0;
}

//创建图 
void CreatAdjGraph_adjList(AdjGraph &G)
{
    ArcNode *p;
    cout<<"Please input Vnum and Anum:"<<endl;
    cin>>G.Vnum>>G.Anum;
    cout<<"Please input Vertices:"<<endl;//创建表头 
    for(int i=0;i<G.Vnum;i++)
    {
        cin>>G.vertices[i].data;
        G.vertices[i].firstarc=NULL;
    }
    cout<<"Please input Arc[i][j]:"<<endl;//创建链表
    for(int k=0;k<G.Anum;k++)
    {
        p=(ArcNode*)malloc(sizeof(ArcNode));
        char v1,v2;
        cin>>v1>>v2;
        int i=LocateVex(v1,G);
        int j=LocateVex(v2,G);
        int w;
        cin>>w;
        p->adjvesx=j;
        p->info=w;
        p->nextarc=G.vertices[i].firstarc;
        G.vertices[i].firstarc=p; 
    } 
}

//深搜算法 
void DFS(AdjGraph G,int i)
{
    ArcNode*p;
    visited[i]=1;
    p=G.vertices[i].firstarc;
    while(p)
    {
        if(!visited[p->adjvesx])
        {
            visited[p->adjvesx]=1;
            cout<<p->adjvesx<<endl;
        }

        p=p->nextarc;
    }
    return;
}

//调用深搜算法 
void DFSTraverse(AdjGraph G)
{
    for(int i=0;i<G.Vnum;i++)
        visited[i]=0;
    for(int i=0;i<G.Vnum;i++)
    {
        if(!visited[i])
            DFS(G,i);
    }
}

//主函数 
int main()
{
    AdjGraph G;
    CreatAdjGraph_adjList(G);
    DFSTraverse(G);
    return 0;
} 
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109

BFS

宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。

我们可以图示清楚的了解算法的具体实施过程：
这里写图片描述

基于邻接矩阵的BFS：

void BFS_Graph(GraphAMatrix G){
    //图的广度优先遍历
    int i,j,e;//i j 为循环控制变量 e为取队列元素变量
    CQueue  Q;
    int *visited = (int *)malloc(sizeof(int)*G.numVertexes);//标记数组
    InitCQueue(&Q);
    for(int i=0;i<G.numVertexes;i++){
        //遍历所有顶点 非连通图的情况化 要遍历全部加上循环
        if(!visited[i]){
            printf("%d",i);
            visited[i] = 1;
            EnCQueue(&Q,i);//起点入队列
            while(!CQueue(Q)){//循环操作
                DeQueue(&Q,&e);//出队列
                for(int j=0;j<G.numVertexes;j++){
                    //遍历顶点集合
                    if(!visited[j]&&G.edges[e][j]){
                        //判断当前结点是否被访问过 且与出队结点是否相连
                        printf("%d",j);
                        visited[j] = 1;
                        EnCQueue(&Q,j); 
                    } 
                } 
            } 
        } 
    } 
    free(visited);
    printf("\n");
} 
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

基于邻接表的BFS

void BFS_GraphADJList(GraphADJList G){
    //图的广度优先遍历
    int i,j,e;//i j 为循环控制变量 e为取队列元素变量
    CQueue  Q;
    EdgeNode *p; 
    int *visited = (int *)malloc(sizeof(int)*G.numVertexes);//标记数组
    InitCQueue(&Q);
    for(int i=0;i<G.numVertexes;i++){
        //遍历所有顶点 非连通图的情况化 要遍历全部加上循环
        if(!visited[i]){
            printf("%d",i);
            visited[i] = 1;
            EnCQueue(&Q,i);//起点入队列
            while(!CQueue(Q)){//循环操作
                DeQueue(&Q,&e);//出队列
                p = G.adjList[e].firstedge;//从顶点的链表的第一个边结点开始 
                while(p){
                    j = p->adjvex;//记录当前边的终点序号 
                    if(!visited[j]){
                        printf("%d",j);
                        visited[j] = 1;
                        EnCQueue(&Q,j); 
                    } 
                    p = p->next;//移动到下一条边 
                }
            } 
        } 
    } 
    free(visited);
    printf("\n");
} 
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

DFS与BFS比较

DFS深度优先搜索，空间需求较低，不需要BFS需要一个队列保存搜索过程中搜索记录；其次，深搜在搜索过程中要考虑回溯，在搜索HTML链接，爬取数据方面适用颇多；多用于解决连通性问题。

BFS广度优先搜索，空间需求较高，根据其搜索模式，便于求解最短路径问题，上文提到的Dijkstral和prim算法均基于其思想，因为是按层进行搜索，所以很容易求得最短路径。

禅与编程艺术
关注
专栏目录
理解数据结构——图的DFS和BFS
weixin_44522586的博客
11-03 4583
理解数据结构——图的DFS和BFS 在图算法和搜索算法中，dfs和bfs是常见的两种遍历方式。且二者常常千变万化，出现于各类题型，如最短路径、树形dp中，那么我们该如何理解这两种算法思想呢。 1.DFS 深度优先搜索 顾名思义，即当我们对某个树or图进行搜索时，一条道走到黑，“不撞南墙不回头”。dfs总是沿着某个最深的方向来进行搜索，直到无路可走。 假设有下面这么一个树形结构（此处用树型结构，是为...
bfs和dfs算法
qq_57968062的博客
10-11 5788
bfs（广度优先搜索） 从某一个顶点出发开始访问，被访问的顶点做相应的标记，输出访问顶点。 从被访问的顶点出发，搜索与该顶点有边的关联的某个未被访问的邻接点，并做相应标记。 再从根据上述中所有被访问的邻接点，访问与这些邻接点相关的未被访问的邻接点，直到所有顶点访问完为止。 实现代码 #include<iostream> #include<queue> using namespace std; int visit[101],cnt,n,g[101][101]; int main.
图的DFS和BFS算法
Gerald_Jones的博客
05-02 8486
前言 文章主要介绍数据结构知识板块中图的两种不同存储结构下（邻接表和邻接矩阵）BFS和DFS遍历算法。BFS和DFS应用领域不再说明，深搜和广搜的遍历算法十分重要。 DFS 原理：深度优先搜索，顾名思义即为一条道走到黑的搜索策略，行不通退回来换另外一条道再走到黑，依次直到搜索完成。其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次。...
[Algorithms] Graph Traversal (BFS and DFS)
weixin_33936401的博客
06-26 93
Graph is an important data structure and has many important applications. Moreover, grach traversal is key to many graph algorithms.There are two systematic ways to traverse a g...
图的BFS算法和DFS算法
like_study_cat的博客
09-05 346
BFS(breadth first search)广度优先搜索，和二叉树广度优先搜索算法一样，一层一层的搜索，只不过得先找个起始点，如下图所示，比如起始点设为A，那就是A,B,C,D,E,F DFS，也是先找个起始点，然后一条路走到底，走到不能走为止，再往回看上一个点的其他路径，直到探索完所有的点。如下图所示，不如起始点设为A，那就是，A,B,D,F,E,C，当然走法有多种。 BFS可以用queue(先进先出)来实现。 DFS可以用栈来实现(后进先出)来实现。 BFS: graph = {
Graph、DFS、BFS
weixin_30279751的博客
09-01 160
Graph.java package Graph; import LinearLIst.bag.Bag; import edu.princeton.cs.algs4.In; public class Graph { private final int V; //顶点数目 private int E; //边的数目 ...
DFS_BFS.rar_DFS in java_DFS program in java_DFS_BFS_dfs java_jav
09-24
`Queue.class`可能是实现队列的类，`myEdge.class`和`Edge.class`可能分别表示图中边的数据结构，它们可能包含邻接节点信息，帮助DFS和BFS算法找到下一个要访问的节点。 在实际应用中，DFS和BFS各有优势。DFS适用于...
BFS和DFS算法可视化（js实现）
01-17
**BFS（广度优先搜索）与DFS（深度优先搜索）是图论和树结构中常用的两种搜索算法，主要用于遍历或查找树或图。在本项目中，这两种算法通过JavaScript语言进行了可视化实现，旨在帮助学习者更好地理解和掌握这两种...
DFS BFS 图.zip_DFS BFS_bfs_bfs dfs_dfs_dfs bfs输出图
09-20
深度优先遍历（DFS, Depth First Search）和广度优先遍历（BFS, Breadth First Search）是图论中的两种基本搜索算法，用于遍历或查找图中的所有节点。这两种算法都起始于图中的一个特定节点，通常称为起点，然后按照...
C语言：图的DFS和BFS（内附代码和算法思路）.docx
11-01
在本文档中，我们讨论了如何使用C语言实现无向图的深度优先遍历（DFS）和广度优先遍历（BFS）。首先，我们需要理解数据结构中的图，它由顶点（vertices）和边（edges）组成，无向图意味着边没有方向。图的存储通常有...
图文详解 DFS 算法 和 BFS 算法
李嘉图呀李嘉图的博客
06-01 763
前言 深度优先遍历（Depth First Search, 简称 DFS） 与广度优先遍历（Breath First Search）是图论中两种非常重要的算法，生产上广泛用于拓扑排序，寻路（走迷宫），搜索引擎，爬虫等，也频繁出现在 leetcode，高频面试题中。 本文将会从以下几个方面来讲述深度优先遍历，广度优先遍历，相信大家看了肯定会有收获。 深度优先遍历，广度优先遍历简介 习题演练 DFS，BFS 在搜索引擎中的应用 深度优先遍历，广度优先遍历简介 深度优先遍历
Graph+DFS+BFS
unspoken0714的博客
05-15 220
Formal definition G: 表示Graph， G = (V, E) V: 表示节点集(nodes set) E: 表示边集（edges set） G1 =(V 1 ​ ,E 1 ​ ), V1 ​={0,1,2}, E1​ =∅ G2 ​=(V 2 ​ ,E 2 ​ ), V2 ​={0,1,2}, E2 ​={{0,1},{0,2}} G3 ​=(V 3 ​ ,E 3 ​ ), V3 ​={0,1,2,3}, E3 ={{0,1},{0,2},{1,2},{1,3}} ...
Graph——bfs,dfs
vuscity的博客
03-22 376
做个记录：BFS——queue实现#include<iostream> #include<cstring> #include<queue> using namespace std;#define N 100struct Graph { int vexnum; int arcnum; char vexs[N]; int arcs[N][N]; };int Loc_ve
图的DFS
weixin_42394385的博客
07-04 310
邻接矩阵的DFS： typedef int Boolean; Boolean visited[MAX]; // 邻接矩阵的深度优先递归算法 void DFS(MGraph G, int i) { int j; visited[i] = True; printf("%c ", G->vexs[i]); for (j = 0; j < G->numVe...
数据结构与算法-图论-DFS/BFS
最新发布
2303_76624483的博客
04-24 2614
我们首先定义一个图结构来表示城市中的路口（节点）和道路（边），然后实现 BFS 搜索找到最短路径。
[数据结构]Graph之拓扑排序BFS&DFS实现
yuchenchenyi的博客
06-17 2261
什么是拓扑排序在这里就不说了。直接讲讲拓扑排序的DFS和BFS实现算法。 一、DFS实现拓扑排序 算法描述：递归实现 利用了一个辅助函数实现递归，下面先对这个辅助函数进行分析： base case：当所有的“邻居”点都被访问过后结束递归，并将当前节点加入到队列的0号位置 general case：如果存在未被访问的“邻居”节点，则对其进行访问（递归） 实现代码： te
图(Graph)-图的遍历(DFS&BFS)
Edidaughter的博客
10-31 482
1.图的深度优先遍历-DFS(Depth First Search) 1.1 深度优先遍历 深度优先遍历，有时候也成为了深度优先搜索，简称DFS，其实，就是像一棵树的前序遍历。它从图中弄的摸个节点v触发，访问此顶点，然后从v的未被访问的邻接点触发深度优先遍历图，直到图中所有和v有路径相同的顶点的都被访问到。若图中尚有顶点未被访问，则另选图中的一个为被访问的顶点做起始点，重复上述过程，直至图中的所有顶点都被访问到为止。 深度优先搜索是通过栈来实现的。 ...
Graph-基于BFS/DFS的单源路径问题
zhangkai1992的专栏
10-25 140
问题： 问题给定图中的一个起始点，求解该点到另一个点的路径path 图数据 7 6 0 1 0 2 1 3 2 3 1 4 2 6 DFS: 深度优先遍历代码 package graph; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; public class GraphDFSSingleSourcePath { private
Java实现福特-弗洛克森最大流算法：BFS与DFS搜索路径
本篇Java源代码是实现最大流算法的一种实现，...通过结合BFS和DFS，代码实现了寻找增广路径的高效搜索，确保了算法的正确性和效率。这个源代码对于理解最大流算法的实现原理以及如何在Java中应用具有很高的参考价值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值