【DFS and BFS】

已于 2022-02-28 12:36:23 修改
阅读量169 收藏
点赞数
分类专栏： 数据结构与算法 笔记 文章标签： 深度优先 宽度优先
于 2022-02-26 22:54:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40534145/article/details/123157772
版权

DFS and BFS

Preface

最近在看数据结构与算法，当前进度到DFS和BFS。
网上内容尤其是代码内容鱼龙混杂，因此mark一下正确可运行的DFS和BFS。亲测可用，放心食用。

代码内容借鉴：
https://www.cnblogs.com/Luoters/p/12033473.html
基于该代码，修改了部分语法错误。

Breief Introduction

DFS: Depth First Search 深度优先搜索
BFS: Breadth First Search 广度优先搜索

DFS和BFS是两种图遍历的方式。二者都是按照约定规则对图进行遍历。
DFS的主要实现是通过递归和回溯。与树中的前序、中序、遍历相似，按既定规则一条路走到黑，若此路不通则退回到有其他方式的路上继续遍历，因此会遍历所有的可能路径，时间消耗更多一些。
BFS的主要实现靠逻辑遍历。与树中的层序遍历类似，按既定规则把每个元素的可能路径探索一遍，一层一层进行，这其中需要新建一个队列帮助，因此空间消耗更多一些。
另外，BFS的优势还在于，能够连续找到与同一元素关联的数据。

图的表示主要有邻接矩阵和邻接表两种，因此分别基于图的这两种表示方法实现DFS和BFS。
多说无益，直接上代码。

Code

Based on Adjacent Matrix

基于邻接矩阵的无向图，分别实现DFS和BFS。

DFS Based on Adjacent Matrix

#include <iostream>
#define MAXNUM 10
using namespace std;
typedef struct
{
    int vnum;
    int anum;
    char ver[MAXNUM];
    char arc[MAXNUM][MAXNUM];
}MGraph;
int Location(MGraph& G, char e)
{
    for (int i = 0; i < G.vnum; i++)
    {
        if (G.ver[i] == e)
            return i;
    }
    return -1;
}
bool CreateGraph(MGraph& G, int vnum, int anum, char v[], char a[])
{
    G.vnum = vnum;
    G.anum = anum;
    for (int i = 0; i < G.vnum; i++)
    {
        G.ver[i] = v[i];
    }
    for (int i = 0; i < G.vnum; i++)
    {
        for (int j = 0; j < G.vnum; j++)
        {
            G.arc[i][j] = 0;
        }
    }
    int t = 0;
    for (int i = 0; i < G.vnum; i++)
    {
        char m = a[t++];
        char n = a[t++];
        t++;
        t++;
        int p = Location(G, m);
        int q = Location(G, n);
        G.arc[p][q] = 1;
        G.arc[q][p] = 1;
    }
    return true;
}
int FirstAdjVex(MGraph& G, int i)
{
    for (int j = 0; j < G.vnum; j++)
    {
        if (G.arc[i][j] == 1)
        {
            return j;
        }
    }
    return -1;
}
int NextAdjVex(MGraph& G, int i, int j)
{
    for (int k = j+1; k < G.vnum; k++)
    {
        if (G.arc[i][k] == 1)
        {
            return k;
        }
    }
    return -1;
}
int visited[MAXNUM];
void DFS(MGraph& G, int i)
{
    visited[i] = 1;
    cout << G.ver[i] << endl;
    int k = FirstAdjVex(G, i);
    cout << "first " << G.ver[i] << " to " << G.ver[k] << endl;
    while (k != -1)
    {
        if(visited[k] == 0)
        {
            cout << G.ver[k] << endl;
            visited[k] = 1;
            DFS(G, k);
        }
        k = NextAdjVex(G, i, k);
        cout << "next " << G.ver[i] << " to " << G.ver[k] << endl;
    }
}
void DFSTraverse(MGraph& G)
{
    for (int i = 0; i < G.vnum; i++)
    {
        visited[i] = 0;
    }
    for (int i = 0; i < G.vnum; i++)
    {
        if (visited[i] == 0)
        {
            DFS(G, i);
        }
    }
}
int main()
{
    char v[] = "abcdef";
    char a[] = "ab, ac, ad, be, ce, df";
    MGraph G;
    CreateGraph(G, 6, 6, v, a);
    DFSTraverse(G);
    return 0;
}

输出结果如下：

 a
first a to b
b
b
first b to a
next b to e
e
e
first e to b
next e to c
c
c
first c to a
next c to e
next c to  
next e to  
next b to  
next a to c
next a to d
d
d
first d to a
next d to f
f
f
first f to d
next f to  
next d to  
next a to

BFS Based on Adjacent Matrix

#include <iostream>
#define MAXNUM 10
using namespace std;

typedef struct
{
    int vnum;
    int anum;
    char ver[MAXNUM];
    char arc[MAXNUM][MAXNUM];
}MGraph;
int Location(MGraph& G, char e)
{
    for (int i = 0; i < G.vnum; i++)
    {
        if (G.ver[i] == e)
            return i;
    }
    return -1;
}
bool CreateGraph(MGraph& G, int vnum, int anum, char v[], char a[])
{
    G.vnum = vnum;
    G.anum = anum;
    for (int i = 0; i < G.vnum; i++)
    {
        G.ver[i] = v[i];
    }
    for (int i = 0; i < G.vnum; i++)
    {
        for (int j = 0; j < G.vnum; j++)
        {
            G.arc[i][j] = 0;
        }
    }
    int t = 0;
    for (int i = 0; i < G.vnum; i++)
    {
        char m = a[t++];
        char n = a[t++];
        t++;
        t++;
        int p = Location(G, m);
        int q = Location(G, n);
        G.arc[p][q] = 1;
        G.arc[q][p] = 1;
    }
    return true;
}
int FirstAdjVex(MGraph& G, int i)
{
    for (int j = 0; j < G.vnum; j++)
    {
        if (G.arc[i][j] == 1)
        {
            return j;
        }
    }
    return -1;
}
int NextAdjVex(MGraph& G, int i, int j)
{
    for (int k = j+1; k < G.vnum; k++)
    {
        if (G.arc[i][k] == 1)
        {
            return k;
        }
    }
    return -1;
}

typedef struct QNode
{
    char data;
    QNode* next;
}QNode, *QueuePtr;
typedef struct
{
    QueuePtr first;
    QueuePtr last;
}LinkQueue;
bool InitQueue(LinkQueue& Q)
{
    Q.first = (QNode*)malloc(sizeof(QNode));
    if (!Q.first) return false;
    Q.first->next = NULL;
    Q.last = Q.first;
    return true;
}
bool EnQueue(LinkQueue& Q, char e)
{
    auto q = (QNode*)malloc(sizeof(QNode));
    if (!q) return false;
    q->data = e;
    q->next = NULL;
    Q.last->next = q;
    Q.last = q;
    return true;
}
bool DeQueue(LinkQueue& Q, char& e)
{
    if (Q.first == Q.last)
        return false;
    auto q = Q.first->next;
    if (q != NULL)
    {
        Q.first->next = q->next;
        e = q->data;
    }
    if(q == Q.last)
    {
        Q.last = Q.first;
    }
    return true;
}
bool EmptyQueue(LinkQueue& Q)
{
    if (Q.first == Q.last)
        return true;
    return false;
}

int visited[MAXNUM];
void BFS(MGraph& G)
{
    for (int i = 0; i < G.vnum; i++)
    {
        visited[i] = 0;
    }
    LinkQueue Q;
    InitQueue(Q);
    for (int i = 0; i < G.vnum; i++)
    {
        if (visited[i] == 0)
        {
            EnQueue(Q, G.ver[i]);
            visited[i] = 1;
            cout << G.ver[i] << endl;
            while (!EmptyQueue(Q))
            {
                char e;
                DeQueue(Q, e);
                int v = Location(G, e);
                int w = FirstAdjVex(G, v);
                while (w != -1)
                {
                    if (visited[w] == 0)
                    {
                        EnQueue(Q, G.ver[w]);
                        visited[w] = 1;
                        cout << G.ver[w] << endl;
                    }
                    w = NextAdjVex(G, v, w);
                }
            }
        }
    }
    return;
}
int main()
{
    char v[] = "abcdef";
    char a[] = "ab, ac, ad, be, ce, df";
    MGraph G;
    CreateGraph(G, 6, 6, v, a);
    BFS(G);
    return 0;
}

Based on Adjacent List

基于邻接表的无向图，分别实现DFS和BFS。

DFS Based on Adjacent List

#include <iostream>
#define MAXNUM 10
using namespace std;
typedef struct ANode
{
    int AdjVex;
    ANode* next;
}ANode;
typedef struct VNode
{
    char data;
    ANode *firstArc;
};
typedef struct
{
    int vnum;
    int anum;
    VNode vex[MAXNUM];
}ALGraph;
int Location(ALGraph& G,char e)
{
    for (int i = 0; i < G.vnum; i++)
    {
        if (G.vex[i].data == e)
            return i;
    }
    return -1;
}
bool CreateGraph(ALGraph& G, int vnum, int anum, char v[], char a[])
{
    G.vnum = vnum;
    G.anum = anum;
    for (int i = 0; i < G.vnum; i++)
    {
        G.vex[i].data = v[i];
        G.vex[i].firstArc = NULL;
    }
    int t = 0;
    for (int i = 0; i < G.vnum; i ++)
    {
        char m = a[t++];
        char n = a[t++];
        t++;
        t++;
        int p = Location(G, m);
        int q = Location(G, n);
        ANode *p1, *p2, *p3;
        p1 = (ANode*)malloc(sizeof(ANode));
        p1->AdjVex = p;
        p1->next = NULL;
        if (G.vex[q].firstArc == NULL)
        {
            G.vex[q].firstArc = p1;
        }
        else
        {
            p3 = G.vex[q].firstArc;
            while (p3->next)
            {
                p3 = p3->next;
            }
            p3->next = p1;
        }
        p2 = (ANode*)malloc(sizeof(ANode));
        p2->AdjVex = q;
        p2->next = NULL;
        if (G.vex[p].firstArc == NULL)
        {
            G.vex[p].firstArc = p2;
        }
        else
        {
            p3 = G.vex[p].firstArc;
            while(p3->next)
            {
                p3 = p3->next;
            }
            p3->next = p2;
        }
    }
    return true;
}
int FirstAdjVex(ALGraph& G, int i)
{
    if (G.vex[i].firstArc)
        return G.vex[i].firstArc->AdjVex;
    return -1;
}
int NextAdjVex(ALGraph& G, int i, int j)
{
    auto p = G.vex[i].firstArc;
    if (p->AdjVex == j and p->next)
        return p->next->AdjVex;
    else if(p->next)
        p = p->next;
    return -1;
}
int visited[MAXNUM];
void DFS(ALGraph &G, int i)
{
    visited[i] = 1;
    cout << G.vex[i].data << endl;
    int k = FirstAdjVex(G, i);
    cout << "first " << G.vex[i].data << " to " << G.vex[k].data << endl;
    while (k != -1)
    {
        if(visited[k] == 0)
        {
            cout << G.vex[k].data << endl;
            visited[k] = 1;
            DFS(G, k);
        }
        k = NextAdjVex(G, i, k);
        cout << "next " << G.vex[i].data << " to " << G.vex[k].data << endl;
    }
}
void DFSTraverse(ALGraph & G)
{
    for (int i = 0; i < G.vnum; i++)
    {
        visited[i] = 0;
    }
    for (int i = 0; i < G.vnum; i++)
    {
        if (visited[i] == 0)
        {
            DFS(G, i);
        }
    }
}
int main()
{
    char v[] = "abcdef";
    char a[] = "ab, ac, ad, be, ce, df";
    ALGraph G;
    CreateGraph(G, 6, 6, v, a);
    // BFS(G);
    DFSTraverse(G);
    return 0;
}

输出结果如下：

a
first a to b
b
b
first b to a
next b to e
e
e
first e to b
next e to c
c
c
first c to a
next c to e
next c to L
next e to L
next b to L
next a to c
next a to L
d
first d to a
next d to f
f
f
first f to d
next f to L
next d to L

BFS Based on Adjacent List

#include <iostream>
#define MAXNUM 10
using namespace std;

 typedef struct ANode
{
    int AdjVex;
    ANode* next;
}ANode;
typedef struct VNode
{
    char data;
    ANode *firstArc;
};
typedef struct
{
    int vnum;
    int anum;
    VNode vex[MAXNUM];
}ALGraph;
int Location(ALGraph& G,char e)
{
    for (int i = 0; i < G.vnum; i++)
    {
        if (G.vex[i].data == e)
            return i;
    }
    return -1;
}
bool CreateGraph(ALGraph& G, int vnum, int anum, char v[], char a[])
{
    G.vnum = vnum;
    G.anum = anum;
    for (int i = 0; i < G.vnum; i++)
    {
        G.vex[i].data = v[i];
        G.vex[i].firstArc = NULL;
    }
    int t = 0;
    for (int i = 0; i < G.vnum; i ++)
    {
        char m = a[t++];
        char n = a[t++];
        t++;
        t++;
        int p = Location(G, m);
        int q = Location(G, n);
        ANode *p1, *p2, *p3;
        p1 = (ANode*)malloc(sizeof(ANode));
        p1->AdjVex = p;
        p1->next = NULL;
        if (G.vex[q].firstArc == NULL)
        {
            G.vex[q].firstArc = p1;
        }
        else
        {
            p3 = G.vex[q].firstArc;
            while (p3->next)
            {
                p3 = p3->next;
            }
            p3->next = p1;
        }
        p2 = (ANode*)malloc(sizeof(ANode));
        p2->AdjVex = q;
        p2->next = NULL;
        if (G.vex[p].firstArc == NULL)
        {
            G.vex[p].firstArc = p2;
        }
        else
        {
            p3 = G.vex[p].firstArc;
            while(p3->next)
            {
                p3 = p3->next;
            }
            p3->next = p2;
        }
    }
    return true;
}
int FirstAdjVex(ALGraph& G, int i)
{
    if (G.vex[i].firstArc)
        return G.vex[i].firstArc->AdjVex;
    return -1;
}
int NextAdjVex(ALGraph& G, int i, int j)
{
    auto p = G.vex[i].firstArc;
    if (p->AdjVex == j and p->next)
        return p->next->AdjVex;
    else if(p->next)
        p = p->next;
    return -1;
}

typedef struct QNode
{
    char data;
    QNode* next;
}QNode, *QueuePtr;
typedef struct
{
    QueuePtr first;
    QueuePtr last;
}LinkQueue;
bool InitQueue(LinkQueue& Q)
{
    Q.first = (QNode*)malloc(sizeof(QNode));
    if (!Q.first) return false;
    Q.first->next = NULL;
    Q.last = Q.first;
    return true;
}
bool EnQueue(LinkQueue& Q, char e)
{
    auto q = (QNode*)malloc(sizeof(QNode));
    if (!q) return false;
    q->data = e;
    q->next = NULL;
    Q.last->next = q;
    Q.last = q;
    return true;
}
bool DeQueue(LinkQueue& Q, char& e)
{
    if (Q.first == Q.last)
        return false;
    auto q = Q.first->next;
    if (q != NULL)
    {
        Q.first->next = q->next;
        e = q->data;
    }
    if(q == Q.last)
    {
        Q.last = Q.first;
    }
    return true;
}
bool EmptyQueue(LinkQueue& Q)
{
    if (Q.first == Q.last)
        return true;
    return false;
}

int visited[MAXNUM];
void BFS(ALGraph& G)
{
    for (int i = 0; i < G.vnum; i++)
    {
        visited[i] = 0;
    }
    LinkQueue Q;
    InitQueue(Q);
    for (int i = 0; i < G.vnum; i++)
    {
        if (visited[i] == 0)
        {
            EnQueue(Q, G.vex[i].data);
            visited[i] = 1;
            cout << G.vex[i].data << endl;
            while (!EmptyQueue(Q))
            {
                char e;
                DeQueue(Q, e);
                int v = Location(G, e);
                int w = FirstAdjVex(G, v);
                while (w != -1)
                {
                    if (visited[w] == 0)
                    {
                        EnQueue(Q, G.vex[w].data);
                        visited[w] = 1;
                        cout << G.vex[w].data << endl;
                    }
                    w = NextAdjVex(G, v, w);
                }
            }
        }
    }
    return;
}
int main()
{
    char v[] = "abcdef";
    char a[] = "ab, ac, ad, be, ce, df";
    ALGraph G;
    CreateGraph(G, 6, 6, v, a);
    BFS(G);
    // DFSTraverse(G);
    return 0;
}
日晚倦梳头因为有男友
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-DFS and BFS-PPT
02-04
"数据结构-DFS和BFS-PPT" 数据结构是计算机科学中的一种基本概念，它是指数据在计算机中的组织和存储方式。DFS（Depth-First Search，深度优先搜索）和BFS（Breadth-First Search，广度优先搜索）是两种常用的图...
DFS和BFS的C++实现
11-30
在DFS_and_BFS压缩包文件中，可能包含了更多关于DFS和BFS的实际案例、练习题和扩展应用的代码，供学习者进一步实践和研究。通过这些资源，初学者能够更好地掌握这两种重要的图遍历算法，并将其运用到实际项目中。
DFS and BFS
yyds_hpu的博客
03-20 1259
DFS and BFS 一. DFS的基本概念 深度优先搜索（Depth First Search，简称DFS）：一种用于遍历或搜索树或图的算法。 沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当搜索遇到阻碍，如节点 的所在边都己被探寻过或者在搜寻时结点不满足条件，搜索将回溯到发现节点 的那条边的起始节点,换条路接着搜。 注意可以将dfs理解为栈，将各个子节点当作一个个的栈，然后将每个栈都遍历出来 问题示例 1.树或图的遍历问题 遍历无根树 #include<iostream> #inclu
DFS and BFS （一）
remember_your_dream的博客
06-06 184
BFS and DFSA
dfs and bfs template
Golemon的博客
07-26 171
BFS DFS
图论-DFSandBFS
Fight_adu的博客
04-21 195
深度优先遍历: 算法步骤(递归): ①初始化图中所有顶点未被访问 ②从图中的某个顶点v出发，访问v并标记已访问 ③依次检查v的所有邻接点w,如果w未被访问，则从w出发进行深度优先遍历，重复②和③ Code: #include<iostream> #include<vector> #include<algorithm> using namespace std; ...
搜索专题(dfs and bfs)
Deep的博客
07-13 281
搜索，顾名思义，就是对某样事物进行寻找。好了我就不多废话了。搜索有多种形式，常见的dfs（深度优先搜索）和bfs（广度优先搜索）等等，这也就是今天的主要内容： 1.dfs：深度优先搜素，就相当于你去逛街，有很多条街相通，你选择先走任意一条街，如果没有自己想要去的店，那么回到上一个路口，再选择一条没走过的路继续走到底。如：因式分解，即输入n，求将n因式分解的总方案数。 首先，看到这题，我首先想到...
leetcode刷题笔记-DFS and BFS
Sengo的博客
08-19 1240
212.Word Search II 在trie分类 529.Minesweeper 不会点击数字的，所以不用考虑这点 class Solution(object): def updateBoard(self, board, click): # 1. 如果是M雷的话，改成X结束 # 2. 如果不是M的话，附近有雷就改成数字结束。否则就是...
DFS与BFS算法
热门推荐
qq_41816189的博客
02-06 2万+
深度优先遍历简称DFS（Depth First Search），广度优先遍历简称BFS（Breadth First Search），它们是遍历图当中所有顶点的两种方式。下面分别介绍两种基本的搜索算法。
Python - 深夜数据结构与算法之 BFS & DFS
BITDDD小栈
12-27 1818
Python BFS/DFS 简介与算法练习。
DFS与BFS
zuyuhuo6777的博客
07-31 621
DFS推荐使用递归的写法 一、判断有向图是否有环 leetcode 207 方法一：拓扑排序（Kahn 算法） 具体到拓扑排序，每一次都从图中删除没有前驱的顶点，这里并不需要真正的做删除操作，我们可以设置一个入度数组，每一轮都输出入度为 00 的结点，并移除它、修改它指向的结点的入度（-1−1即可），依次得到的结点序列就是拓扑排序的结点...
图——图的遍历（DFS与BFS算法详解）
Blusher1的博客
07-15 1693
前面的文章中我们学习了图的基本概念和存储结构，这篇文章就来学习一下图的重要章节——图的遍历。包含深度优先搜索（DFS）和广度优先搜索（BFS）两种方式。
DFS_BFS.zip_邻接矩阵_邻接矩阵结构
09-23
本教程将深入探讨邻接矩阵及其在深度优先搜索（DFS）和广度优先搜索（BFS）中的应用。 邻接矩阵是一种二维数组，用于存储图中顶点之间的关系。如果图是无向的，邻接矩阵是对称的，其中的每个元素`matrix[i][j]`表示...
图 数据结构 BFS DFS
07-08
两种主要的遍历方法是广度优先搜索（BFS）和深度优先搜索（DFS）。BFS从一个起始顶点开始，先访问其邻居，然后是邻居的邻居，直到访问完所有顶点。DFS则是沿着图的分支尽可能深地探索，直到到达叶节点，然后回溯。 ...
LintCode 1189. Minesweeper (BFS/DFS好题）
01-07
Minesweeper ... ‘M’ represents an unrevealed mine, ‘E’ represents an unrevealed empty square, ‘B’ represents a revealed blank square that has no adjacent (above, below, left, right, and
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5131
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
开题报告达达宠物认领信息网站的设计与实现 已通过开题答辩的.docx
07-25
宠物认领信息网站的主要目的是为寻找宠物的失主和寻找新家的宠物提供一个在线的信息交流平台。通过这个平台，失主可以发布失宠信息，寻找走失或遗弃的宠物；而救助人或组织则可以发布待领养的宠物信息，为那些无家可归的宠物寻找一个永久的归宿。 这样的网站通常会提供一个详细的宠物数据库，包括照片、品种、年龄、健康状况等信息，以便让失主能够方便地找到自己的宠物。同时，网站还会提供一些相关的服务，如失主与救助人之间的在线交流、宠物匹配推荐、领养手续办理等，以帮助双方顺利完成宠物的认领和领养过程。 宠物认领信息网站的目的在于提高失宠找到宠物的几率，减少流浪宠物的数量，并为那些无家可归的宠物提供一个温馨的新家。同时，网站还能促进社会对流浪宠物的关注和保护，提高人们的动物保护意识。
开题报告创权法律服务系统 已通过开题答辩的.doc
07-25
进入20世纪80年代，我国加快了改革开放的步伐，市场经济体制已逐步形成，我国的经济发展受世人所瞩目，但法律法规的置后，使经济发展不规范问题暴露的相当严重，特别是社会整体信用的缺失，使消费环境不断恶化。而如今随着城镇化的高速推进，精神追求远不及物质发展迅速，维权问题也越来越成为人们十分关注的社会话题。 维权是指维护个人或群体的合法权益，范围包括人身损害、土地纠纷、 医疗事故、婚姻、家庭、继承等民事纠纷所进行的行政及司法诉讼。维护消费者合法权益关系着全社会每个人的利益，群众利益无小事。维护消费者合法权益正体现着“权为民所用，利为民所谋”。而现如今由于法律规则的不完善加上自身对法律知识的不了解，导致很多公民的权益问题在复杂的社会情况下无法得到妥善的解决，使得公民的财产和心理受到难以弥补的损失，严重威胁到社会的安全与稳定，公民之间的诚信与统一。因此更便捷、迅速地维护公民的合法权益，已经成为了一个刻不容缓去解决的社会问题。
Matlab实现豪猪优化算法CPO-TCN-Multihead-Attention多输入单输出回归预测算法研究.rar
最新发布
07-25
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
bfs and dfs java code
03-29
Here is the Java code for BFS and DFS: BFS: ``` import java.util.*; public class BFS { public void bfs(int[][] adjMatrix, int start) { Queue<Integer> queue = new LinkedList(); boolean[] visited ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值