BFS和DFS的简单遍历（C++实现）and Java实现bfs

最新推荐文章于 2024-03-26 20:22:53 发布
最新推荐文章于 2024-03-26 20:22:53 发布
阅读量1.6k 收藏 4
点赞数 1
分类专栏： 数据结构 文章标签： 搜搜搜
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43237242/article/details/89715423
版权
头文件：
//#include<bits/stdc++.h>
#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<stdlib.h>
#include<vector>
#include<queue>
#include<stack>
#include<string.h>
#include<math.h>
#include<stack>;
using namespace std ;
typedef long long ll;
#define MAXN 10005
#define INF 0x3f3f3f3f
#define MALL (BiTnode *)malloc(sizeof(BiTnode));

vector<int>g[MAXN];				//存图
bool vis[MAXN];					//标记数组

void init(int n)				//初始化
{
    for(int i=1; i<=n; ++i)
    {
        g[i].clear();
        vis[i] = false;
    }
}

DFS（深度优先遍历）：

图的深度优先遍历类似于树的前序遍历。采用的搜索方法的特点是尽可能先对纵深方向进行搜索。这种搜索方法称为深度优先搜索(Depth-First Search)。相应地，用此方法遍历图就很自然地称之为图的深度优先遍历。

过程：

设x是当前被访问顶点，在对x做过访问标记后，选择一条从x出发的未检测过的边(x，y)。若发现顶点y已访问过，则重新选择另一条从x出发的未检测过的边，否则沿边(x，y)到达未曾访问过的y，对y访问并将其标记为已访问过；然后从y开始搜索，直到搜索完从y出发的所有路径，即访问完所有从y出发可达的顶点之后，才回溯到顶点x，并且再选择一条从x出发的未检测过的边。上述过程直至从x出发的所有边都已检测过为止。此时，若x不是源点，则回溯到在x之前被访问过的顶点；否则图中所有和源点有路径相通的顶点(即从源点可达的所有顶点)都已被访问过，若图G是连通图，则遍历过程结束，否则继续选择一个尚未被访问的顶点作为新的顶点，继续遍历。

C++代码（vector存图）：
递归代码：

（注释代码可与 for（）之间相互替换）

void dfs(int v)					//从v开始搜搜搜
{
//    vector<int>::iterator it;
    vis[v] = true;
    cout << v << ' ';
    for(int i=0; i<g[v].size(); ++i)
        if(!vis[g[v][i]])
            dfs(g[v][i]);
//    for(it = g[v].begin(); it!=g[v].end(); ++it)
//        if(!vis[*it])
//            dfs(*it);
}
非递归代码（栈[stack]实现）：

这个代码感觉就像二叉树的非递归前序遍历一样。。。

void dfs_no(int v)				//从v开始搜搜搜
{
    memset(vis, false, sizeof(vis));
    vector<int>::iterator it;
    vis[v] = true;
    cout << v << ' ';
    stack<int>st;
    st.push(v);
    while(!st.empty())
    {
        v = st.top();
        st.pop();
        if(!vis[v])
        {
            cout << v << ' ';
            vis[v] = true;
        }
        for(it = g[v].begin(); it!=g[v].end(); ++it)
        {
            if(!vis[*it])
                st.push(*it);
        }
    }
    cout << '\n';
}

BFS（广度优先遍历）：

步骤：
1、从图中某个顶点V0出发，并访问此顶点；
2、从V0出发，访问V0的各个未曾访问的邻接点W1，W2，…,Wk;然后,依次从W1,W2,…,Wk出发访问各自未被访问的邻接点；
3、重复步骤2，直到全部顶点都被访问为止。

最短路

显然，从v0出发广度优先遍历图，将得到v0到它的各个可达到的路径。我们这里定义路径上的边的数目为路径长度。与深度优先遍历不同，广度优先遍历得到的v0到各点的路径是最短路径（未考虑边权）。

队列实现：

（注释代码可与 for（）之间相互替换）

void bfs(int v)
{
    memset(vis, false, sizeof(vis));
    vis[v] = true;
    cout << v << ' ';
    queue<int >que;
    que.push(v);
//    vector<int>::iterator it;
    while(!que.empty())
    {
        v = que.front();
        que.pop();
        for(int i=0; i<g[v].size(); ++i)
        {
            if(!vis[g[v][i]])
            {
                cout << g[v][i] << ' ';
                que.push(g[v][i]);
                vis[g[v][i]] = true;
            }
        }
//        for(it = g[v].begin(); it!=g[v].end(); ++it)
//        {
//            if(!vis[*it])
//            {
//                cout << *it << ' ';
//                que.push(*it);
//                vis[*it] = true;
//            }
//        }
    }
    cout << '\n';
}

总代码：

//#include<bits/stdc++.h>
#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<stdlib.h>
#include<vector>
#include<queue>
#include<stack>
#include<string.h>
#include<math.h>
#include<stack>;
using namespace std ;
typedef long long ll;
#define MAXN 10005
#define INF 0x3f3f3f3f
#define MALL (BiTnode *)malloc(sizeof(BiTnode));

vector<int>g[MAXN];
bool vis[MAXN];

void init(int n)
{
    for(int i=1; i<=n; ++i)
    {
        g[i].clear();
        vis[i] = false;
    }
}

void bfs(int v)
{
    memset(vis, false, sizeof(vis));
    vis[v] = true;
    cout << v << ' ';
    queue<int >que;
    que.push(v);
//    vector<int>::iterator it;
    while(!que.empty())
    {
        v = que.front();
        que.pop();
        for(int i=0; i<g[v].size(); ++i)
        {
            if(!vis[g[v][i]])
            {
                cout << g[v][i] << ' ';
                que.push(g[v][i]);
                vis[g[v][i]] = true;
            }
        }
//        for(it = g[v].begin(); it!=g[v].end(); ++it)
//        {
//            if(!vis[*it])
//            {
//                cout << *it << ' ';
//                que.push(*it);
//                vis[*it] = true;
//            }
//        }
    }
    cout << '\n';
}

void dfs(int v)
{
//    vector<int>::iterator it;
    vis[v] = true;
    cout << v << ' ';
    for(int i=0; i<g[v].size(); ++i)
        if(!vis[g[v][i]])
            dfs(g[v][i]);
//    for(it = g[v].begin(); it!=g[v].end(); ++it)
//        if(!vis[*it])
//            dfs(*it);
}

void dfs_no(int v)
{
    memset(vis, false, sizeof(vis));
    vector<int>::iterator it;
    vis[v] = true;
    cout << v << ' ';
    stack<int>st;
    st.push(v);
    while(!st.empty())
    {
        v = st.top();
        st.pop();
        if(!vis[v])
        {
            cout << v << ' ';
            vis[v] = true;
        }
        for(it = g[v].begin(); it!=g[v].end(); ++it)
        {
            if(!vis[*it])
                st.push(*it);
        }
    }
    cout << '\n';
}

int main()
{
    int n, m;
    cin >> n >> m;				//n个点，m条关系
    init(n);
    for(int i=0; i<m; ++i)
    {
        int a, b;
        cin >> a >>b;
        g[a].push_back(b);		//将b压入a中
    }
    dfs(1);
    cout << '\n';
    dfs_no(1);
    bfs(1);
    return 0;
}

Java实现BFS（邻接矩阵遍历）

图：

在这里插入图片描述

package liuren.pu;
import java.util.*;
import java.util.Random;
import java.util.Scanner; //读入包
import javax.print.StreamPrintService;
import java.math.BigInteger; //math中的大数包
import java.math.*;
import java.lang.String;
import java.lang.Throwable;//异常

public class binarysearch {
	
	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		System.out.print("输入节点个数：");
		int n = cin.nextInt();
		System.out.println("输入该图的邻接矩阵：");
		int[][] adjMatrix = new int[n+1][n+1];
		boolean[] vis = new boolean[n+1];
		adjMatrix[0][0] = adjMatrix[1][0] = adjMatrix[0][1] = 0;
		for(int i=1; i<=n; ++i) 
			for(int j=1; j<=n; ++j)
				adjMatrix[i][j] = cin.nextInt();
		for(int i=0; i<=n; ++i)  vis[i] = false;	//初始化标记数组
		System.out.println("请输入bfs遍历图的起始节点：");
		int k = cin.nextInt();
		bfs(adjMatrix, vis, n, k);
		cin.close();
	}
	//g是图，vis是标记数组，n是节点总数，k是bfs起始节点
	public static void bfs(int[][] g, boolean vis[], int n, int k) {
		ArrayList<Integer> q = new ArrayList<>();
		System.out.print("V" + k);
		vis[k] = true;
		q.add(k);
		while(!q.isEmpty()) {
			int v = q.get(0);
			q.remove(0);
			for(int i=1; i<=n; ++i) {
				if(g[v][i] == 1 && !vis[i]) {
					System.out.print("->V" + i);
					q.add(i);
					vis[i] = true;
				}
			}
		}
	}
}

输出截图

在这里插入图片描述

（突然有个Java作业是bfs，所以就加进来了~~~~~~）
浦柳人
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
带BFS和DFS的图的实现
12-03
题在压缩文件中，图是用邻接矩阵做的，刚刚接触图的同学可以看一看
C++(数据结构与算法):57---图的遍历（广度优先搜索(BFS)、深度优先搜索(DFS)）
董哥的黑板报
03-12 1401
待续
C++DFS与BFS实现
weixin_42749137的博客
11-22 3914
C++DFS与BFS实现DFSBFS   BFS使用一个queue实现，每次循环对当前点临近的点，都推进队列中，然后就能根据队列来依次访问临近的点，直到队列中没有点为止。   DFS利用一个stack，首先把start推进stack里面，然后循环每次找到当前stack top的临近的未访问的点，访问后，推进stack里面，以便下次循环进行深度搜索。   以下使用图的遍历算法来举例说明。 DFS BFS 广度优先搜索在进一步遍历图中顶点之前，先访问当前顶点的所有邻接结点。 a .首先选择一个顶点作为起始结点，
【C/C++】DFS算法详解
最新发布
WillZhong2012的博客
03-26 329
DFS(Depth-First Search)即深度优先搜索，是一种用于遍历或搜索树或图的算法。在进行DFS时，从起始顶点开始沿着一条路径尽可能深地搜索，直到该路径上所有顶点都被访问过，然后回溯到上一个节点，继续深入搜索其他路径，直到所有节点都被访问过为止。DFS常用于解决迷宫问题、拓扑排序、连通性检测等各种应用场景。DFS的基本原理是利用递归或栈的数据结构来实现。DFS的优点是实现简单、易于理解，适用于解决许多问题，但也存在一些缺点，比如可能会陷入无限循环（对于非连通图）、不一定能找到最短路径等。
图的遍历之DFS与BFS
code_peak
08-08 255
参考：https://wangkuiwu.github.io/2013/04/10/iterator 深度优先搜索DFS 图的深度优先遍历（Depth First Search）和树的先序遍历有一定相似之处，它的基本思想是：假设初始状态是图中所有顶点均未被访问，则从某个顶点 v 出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和 v 有路径相通的顶点都被访问到。 若此时尚有其他顶点未被访问到，则另选一个未被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问
【C++算法】DFS与BFS(例子详解 排列数字，n皇后问题 ，走迷宫)
2301_76265124的博客
11-24 440
深度优先搜索（DFS）与广度优先搜索（BFS）是两种实现搜索不同的方式，一般地，DFS相当于一条道走到底（递归加回溯），而BFS则是层层搜索（个人理解），下面通过几个例子分别理解这两种搜索方式blablabla。
promise的实现与原理
peng687095的博客
09-17 377
实现Promise Promise标准仅描述了then方法的行为，未对catch、all、race方法进行描述，也未规范如何创建一个Promise对象。ES6中Promise提供了以下API。 (1) 构造函数 function Promise(resolver) {} (2) 原型方法 Promise.prototype.then = function() {} Promise.prototype.catch = function() {} (3) 静态方法 Promise....
c++游戏小技巧6：rand()+随机迷宫(3写法:BFS,DFS,并查集)
zzb的博客
07-11 1317
好东西
C++实现DFS以及BFS
金艺群的博客
11-07 825
#include <iostream> #include <vector> #include <queue> #include <functional> using namespace std; // 有向图 class Graph { public: // 初始化 Graph(int size) :table(vector<vector<int>>(size)), size(size) { f
图的DFS和BFS遍历
12-21
代码中包括了图的BFS和DFS遍历还包括了寻找最短路径，给定路长寻找路径，生成图，添加结点，删除节点
graph_bfs_dfs.cpp
12-29
C++实现图的邻接表、邻接矩阵存储方式并输出深度优先遍历和广度优先遍历并输出栈、队列中的变化情况 打印输出队列、栈中入队出队，入栈出栈的情况，可直接运行无编译错误
DFS和BFS的C++实现
11-30
DFS和BFS算法的实现，使用C++语言，适合数据结构初学者学习。
图的遍历（BFS&&DFS）
08-16
主要用于教学C++的学生深度优先搜索和广度优先搜索的基础，为备考CSP-J2的学生拿个一等奖，绰绰有余
图的邻接矩阵表示，深度优先遍历，广度优先遍历实现
03-13
C++实现，数据结构，图的邻接矩阵表示，深度优先遍历，广度优先遍历，DFS，BFS，为什么要五十个字才能上传啊
C++ DFS 与 BFS
L_S_R_的博客
07-06 380
DFS/BFS
C++数据结构之图的遍历——DFS和BFS（带有gif演示）
m0_56398315的博客
08-19 5801
本文介绍了继图的存储结构之后对图进行遍历，分为DFS和BFS两种算法，赋有动态gif图示和相关代码以及注释
c++：DFS与BFS详解
热门推荐
Charles_ke的博客
11-17 1万+
DFS（深度优先搜索）：从某个状态开始，不断转移状态到无法转移为止，然后退回到前一步，继续转移到其他状态，不断重复，直至找到最终的解。          总是从最开始的状态出发，遍历所有的可到达状态。隐式利用栈进行计算 eg：有一个N*M的田，雨后积水，八连通（下图相对w的*部分）的积水被认为连在一起，请给出园里有多少水洼？       ***       *w*       ***
7084:迷宫问题(dfs)
07-22 918
总时间限制: 1000ms 内存限制: 65536kB 描述 定义一个二维数组： int maze[5][5] = {0, 1, 0, 0, 0,0, 1, 0, 1, 0,0, 0, 0, 0, 0,0, 1, 1, 1, 0,0, 0, 0, 1, 0,};它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。输入 一
图的遍历算法之广度优先遍历（BFS）(C++)
smart_jackli的博客
11-18 5271
广度优先遍历的算法实现
BFS和DFS C++算法实现
09-04
引用中的代码是一个DFS的C++实现，而引用中的代码是一个BFS的C++实现。 DFS（深度优先搜索）算法是一种递归的搜索方法，它从图的起始节点开始，不断地向下探索邻接的未访问节点，直到遍历完所有的节点或者满足某个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值