图的遍历：深度优先遍历/搜索（DFS）与广度优先遍历/搜索（BFS）（Java实现）

最新推荐文章于 2022-07-20 17:31:07 发布
最新推荐文章于 2022-07-20 17:31:07 发布
阅读量205 收藏
点赞数 1
分类专栏： # 图 文章标签： 算法 数据结构 java 队列 dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45907832/article/details/107120468
版权

深度优先遍历/搜索（DFS）

基本思想

  • 对于连通图：从初始访问顶点开始，先访问第一个邻接顶点，再以这个邻接顶点为新的初始顶点，访问它的第一个邻接顶点
  • 对于非连通图：对图的连通分量分别进行深度优先遍历
  • 这种方式是优先纵向深入
  • 这是一个递归的过程

算法实现

邻接矩阵的实现

	boolean[] isVisited ;   //记录顶点是否已被访问过
	
	void dfs(Graph<?> G)
	{
		//开始时所有顶点均未访问
		
		isVisited = new boolean[G.getNumOfVertexes()];
		for(int i = 0;i < isVisited.length; i++)
			isVisited[i] = false;

	
		
		//遍历所有顶点，进行DFS
		for(int i = 0; i < G.getNumOfVertexes(); i++)
			if( !isVisited[i])
				dfs(G, i);
	}
	//DFS递归算法部分
	void dfs(Graph<?> G, int i)
	{
		//访问该顶点
		System.out.println(G.getValueByIndex(i).toString());
		
		//标记为已访问
		isVisited[i] = true;
		
		//访问下个邻接顶点
		int j = 0;
		for(j = 0; j < G.getNumOfVertexes(); j++)
			if(G.edges[i][j] != Graph.INFINITY && G.edges[i][j] != 0 && !isVisited[j]) //有边且未被访问
				dfs(G, j);
		
	}

算法分析

  • 邻接矩阵结构：邻接矩阵是二维数组，要查找每个顶点的邻接点需要访问矩阵中的所有元素，所以算法时间复杂度为O(n2)

广度优先遍历/搜索（BFS）

基本思想

  • 类似于树的层序遍历
  • 使用一个辅助队列
  • 首先，将初始顶点入队列，当队列不为空的时候使队列中第一个顶点出队，将出队顶点的所有未访问过的邻接顶点入队，循环上述过程，就遍历了整个图
  • 实质上是先遍历初始顶点的所有邻接顶点，再遍历邻接顶点的邻接顶点，一层层遍历

算法实现

邻接矩阵的实现


	//BFS
	void bfs(Graph<?> G)
	{
		//使用辅助队列（链表）
		LinkedList<Integer> queue = new LinkedList<>();
		
		//开始时所有节点均未被访问
		boolean[] isVisited = new boolean[G.getNumOfVertexes()];
		for(int i = 0; i < G.getNumOfVertexes(); i++)
			isVisited[i] = false;
		
		
		//遍历所有顶点，进行BFS
		for(int i = 0; i <  G.getNumOfVertexes(); i++)
		{
			//对未被访问的顶点搜索
			if(!isVisited[i])
			{
				//访问该顶点
				System.out.println(G.getValueByIndex(i).toString());   //一个访问动作
				
				isVisited[i] = true;    //将该顶点标记为已访问
				
				queue.addLast(i);      //将此顶点入队列
				
				while(!queue.isEmpty())
				{
					i = queue.removeFirst();   //移除现队列中第一个顶点，赋给i
					for(int j = 0; j < G.getNumOfVertexes(); j++)
					{
						//访问下个邻接顶点
						if(G.edges[i][j] != Graph.INFINITY && G.edges[i][j] != 0 && !isVisited[j]) //有边且未被访问
						{
							//访问该顶点
							System.out.println(G.getValueByIndex(j).toString());   //一个访问动作
							
							isVisited[j] = true;    //将该顶点标记为已访问
							
							queue.addLast(j);      //将此顶点入队列
							
						}
					}
				}
			}
			
			
			
		}
	}

算法分析

  • 邻接矩阵结构：邻接矩阵是二维数组，要查找每个顶点的邻接点需要访问矩阵中的所有元素，所以算法时间复杂度为O(n2)

  • 两种算法时间复杂度是一样的，区别在于对顶点的访问顺序不同

  • 当遍历图的时间很长，目的是为了寻找合适的顶点时
    深度优先遍历适合目标比较明确，以找到目标为主要目的的情况
    广度优先遍历适合在不断扩大遍历范围时找到相对最优解的情况

丨惊蛰丨
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JavaScript中的深度优先遍历(DFS)和广度优先遍历(BFS)
01-08
深度优先遍历DFS 与树的先序遍历比较类似。 假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和v有路径相通的...
搜索算法——遍历
weixin_45452083的博客
06-23 3714
一、深度优先和广度优先 深度优先遍历：对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次 广度优先遍历：从上往下对每一层依次访问，在每一层中，从左往右（也可以从右往左）访问结点，访问完一层就进入下一层，直到没有结点可以访问为止。 1、深度优先： 　 采用的是堆栈的形式, 即先进后出，深度优先有回溯的操作(没有路走了需要回头)所以相对而言时间会长一点 //深度优先 function byDeepth(data) { let result = []
关于搜索&遍历
地推
10-18 803
对于搜索来说，我们绝大多数情况下处理的都是叫“所谓的暴力搜索”，或者是说比较简单朴素的搜索，也就是说你在搜索的时候没有任何所谓的智能的情况在里面考虑，很多情况下它做的一件事情就是把所有的结点全部遍历一次，然后找到你要的结果。 基于这样的一个数据结构，如果这个数据结构本身是没有任何特点的，也就是说是一个很普通的树或者很普通的图。那么我们要做的一件事情就是遍历所有的结点。同时保证每个点访问一次且仅访问一次，最后找到结果。 那么我们先把搜索整个先化简情况，我们就收缩到在树的这种情况下来进行搜索...
2020年计算机考研408数据结构真题（客观题）
qq_44111805的博客
04-29 1万+
1、将一个10x10对称矩阵M的上三角部分的元素m,j (1≤i≤j≤10)按列优先存入C语言的一维数组N中，元素m7,2在N中的下标是( )。 A、15 B、16 C、22 D、23 答案：C 解析： 上三角矩阵按列优先存储，先存储仅1个元素的第一列， 再存储有2个元素的第二列，以此类推。m7,2位于左下角，对应右上角的元素为m2,7，在m2,7之前存有: 第1列:1 第2列:2 … 第6列: 6 第7列: 1 前面共存有1+2+3+4+5+6+1=22个元素(数组下标范围为0~21),注意数组下标从0
networkx图论Depth First Search深度优先搜索遍历DFS，基于递归，Python
Zhang Phil
11-07 2581
DFS又称为深度优先遍历，在图论中用于搜索图中的点和路径。简单写一个Python实现，图的表示用networkx。networkx本身提供了节点连接的结构已经提供了对节点状态值保存的便捷手段。 在每个节点中存放一个visited值，boolean类型，如果已经访问过，记为true，不再搜索遍历。 import networkx as nx import matplotlib.pyplot as plt # 记录搜索路径 search_path = [] def my_graph(): #
「算法基础」之二叉树的遍历和搜索
码农的博客
02-25 2011
在二叉树相关的算法中，对于二叉树的搜索和遍历是绕不开的话题「绕开了当我没说😬」。如果你对二叉树的搜索、遍历还没有掌握的很清楚，那么咱就一起来康康。内容包括『二叉树的前序、中序、后序遍历的递归和迭代，以及深度优先搜索、广度优先搜索』 ，如果这几种都掌握了，也希望能看看有什么不对的地方，本算法菜鸟不胜感激。💐
DFS+BFS深度+广度优先遍历.cpp
01-17
DFS+BFS深度+广度优先遍历.cpp
BFS (Breadth-First Search)：广度优先搜索和DFS (Depth-First Search)：深度优先搜
最新发布
04-11
其中，广度优先搜索（Breadth-First Search，简称BFS）和深度优先搜索（Depth-First Search，简称DFS）是两种最基本且广泛使用的图遍历算法。 广度优先搜索（BFS）是一种按层次遍历图的算法。它从图的某个顶点开始...
C#，深度优先搜索（DFS）、广度优先搜索（BFS）算法的源代码与数据可视化
03-18
深度优先搜索（亦称深度优先遍历，Deep First Search，简称DFS），广度优先搜索（亦称广度优先遍历，Breadth First Search，简称BFS）都是很基础的算法，也是大家很熟悉的。算法，又叫宽度优先遍历，或横向优先遍历...
基于Android Studio 实现图的深度、广度优先遍历并实现界面化输出
11-24
学习过程中写的的小程序，图的存储采用的是顺序存储（邻接矩阵）（未给出数据类型定义），实现了DFS和BFS以及原始图的界面化输出。
（有向）图的深度优先遍历算法模板算法(java源码)
01-21
/* * （有向）图的深度优先遍历算法模板 */ package dsa; public abstract class DFS extends GraphTraverse { //变量 protected static int clock = 0;//遍历过程中使用的计时钟 //构造方法 public DFS(Graph g) { super(g); } //深度优先遍历算法 protected Object traverse(Vertex v, Object info) {//从顶点v出发，做深度优先查找 if (UNDISCOVERED != v.getStatus()) return null;//跳过已访问过的顶点（针对非连通图） v.setDStamp(clock++); v.setStatus(DISCOVERED); visit(v, info);//访问当前顶点 for (Iterator it = v.outEdges(); it.hasNext();) {//检查与顶点v Edge e = (Edge)it.getNext();//通过边e = (v, u) Vertex u = (Vertex)e.getVPosInV(1).getElem();//相联的每一顶点u switch (u.getStatus()) {//根据u当前的不同状态，分别做相应处理 case UNDISCOVERED ://若u尚未被发现，则 e.setType(TREE);//e被归类为“树边” traverse(u, info);//从u出发，继续做深度优先查找 break; case DISCOVERED ://若u已经被发现，但对其访问尚未结束，则 e.setType(BACKWARD);//将e归类为“后向跨边” break; default ://VISITED，即对u的访问已经结束 if (u.getDStamp() < v.getDStamp())//若相对于v，u被发现得更早，则 e.setType(CROSS);//将e归类为“横跨边” else//否则 e.setType(FORWARD);//将e归类为“前向跨边” break; } }//至此，v的所有邻居都已访问结束，故 v.setFStamp(clock++); v.setStatus(VISITED);//将v标记为VISITED return null;//然后回溯 } }
遍历与搜索
qq_42752343的博客
08-10 416
一、二叉树的遍历 1.深度优先遍历DFT 在先L后R的前提下： 1）前序遍历V-L-R 2）中序遍历L-V-R（递增序列） 3）后续遍历L-R-V 前序遍历递归方式： vector<int> res; vector<int> PreOrderDFS(TreeNode* root) {//先序递归遍历 if(root==nullptr)//递归结束条件 return; res.push_back(root->val); //先访问当前根节点 PreOrd
高级数据结构与算法 | 深度遍历搜索（DFS）与广度遍历搜索（BFS）
凌桓丶的博客
10-02 726
文章目录深度优先搜索(DFS)员工的重要性图像渲染岛屿的周长被围绕的区域岛屿数量岛屿的最大面积广度优先搜索(BFS)N叉树的层序遍历腐烂的橘子单词接龙最小基因变化打开转盘锁 深度优先搜索(DFS) 深度优先搜索的核心思想就是一条道走到黑，其实就和二叉树的前、中、后序遍历一样，都会先一直沿着一个方向走，当走不通了再往回找其他的路。 //模板 DFS(当前这一步的处理逻辑) { 1. 判断边界，是否已经一条道走到黑了：向上回退 2. 尝试当下的每一种可能 3. 确定一种可能之后，继续下一步 Dfs(
数据结构——图の选择题整理
王王仙贝的博客
07-20 3325
1、若从无向图的任意顶点出发进行一次深度优先搜索即可访问所有顶点，则该图一定是（）A、强连通图B、连通图C、有回路D、一棵树解析选对于A，强连通图的概念是在有向图中的。对于B，连通图证明任意两个顶点之间一定能够相连，因此一定可以到达。对于C，有环图不一定是连通图不一定任意两个顶点均能到达。对于D，树是可以，但是不是树也可以，题目中说的太肯定了，不能选，比如下图就不是树，但可以完成题目中要求的功能。2、对于一个有n个顶点的图若是连通无向图，其边的个数至少为（）；...
操作系统实验c语言页面置换算法(lru和lfu算法)_2020年研究生全国统考计算机试题——数据结构与操作系统试题解析...
weixin_39665762的博客
11-23 2986
一、单项选择题1．将一个10×10对称矩阵M的上三角部分的元素mij(1≤i≤j≤10)按列优先存入C语言的一维数组N中，元素m7,2在N中的下标是：A．15 B．16C．22D．23答案：C解析：上三角矩阵列优先存储模式：先存储具有一个元素第一列，再存储具有两个元素的第二列，以此类推。m7,2说明1-6列均已存满，故此元素是第1+2+3+4+5+6+2个被存储单元。注意：C语言...
图的深度优先搜索（DFS）和广度优先搜索（BFS）及其Java实现
厚积而薄发，谋定而后动
05-24 1万+
一、背景知识： 1、图的表示方法：邻接矩阵（二维数组）、邻接表（链表数组【链表的链表】）。 2、图的搜索方法：深度优先搜索（DFS）和广度优先搜索（BFS）。 3、深度优先搜索（DFS）：          （1）用栈记录下一步的走向。访问一个顶点的过程中要做三件事：                ①访问顶点                ②顶点入栈，以便记住它
深度优先遍历（搜索）（DFS）
HAN Kai
03-05 1658
深度优先遍历(Depth_First_Search)，也称为深度优先搜索，简称DFS。 无向图 无向图对应的邻接矩阵 深度优先遍历其实就是一个递归的过程，像一棵树的前序遍历。它从图中某个顶点v出发，访问此顶点，然后从v的未访问的邻接点出发深度优先遍历图，直至图中所有和v有路径相通的顶点都被访问到。事实上，这里指的是连通图，对于非连通图，只需要对它的连通分量分别进行深度
图的遍历——深度优先搜索和广度（宽度）优先搜索（含例题）
热门推荐
黑色吊椅的博客
02-01 3万+
专栏导读及目录https://blog.csdn.net/createprogram/article/details/86741044 深度优先搜索 DFS基本思想 基本步骤： 1.从图中某个顶点v0出发，首先访问v0;   2.访问结点v0的第一个邻接点，以这个邻接点vt作为一个新节点，访问vt所有邻接点。直到以vt出发的所有节点都被访问到，回溯到v0的下一个未被访问过的邻接点，以这个...
玩转图论算法（2）图的深度优先遍历【Java实现】
mike_jun的博客
04-24 686
3-1 图的两种形式遍历 所谓图的遍历（graph traversal），也称为搜索（search），就是从图中某个顶点出发，沿着一些边访遍图中所有的顶点，且使 每个顶点仅被访问一次。遍历可以采取两种方法进行：深度优先搜索（DFS，depth first search） 和广度优先搜索（BFS，breadth first search）。 3-2 图的深度优先...
图的广度优先遍历与深度优先遍历代码实现
09-06
### 回答1： 以下是图的广度优先遍历和深度优先遍历的Python实现代码： ```python # 图的广度优先遍历 def bfs(graph, start): visited = set() # 已访问过的节点集合 queue = [start] # 初始化队列 while queue: node = queue.pop(0) # 取出队首节点 if node not in visited: visited.add(node) print(node, end=' ') for neighbor in graph[node]: if neighbor not in visited: queue.append(neighbor) # 图的深度优先遍历 def dfs(graph, start, visited=None): if visited is None: visited = set() # 已访问过的节点集合 visited.add(start) print(start, end=' ') for neighbor in graph[start]: if neighbor not in visited: dfs(graph, neighbor, visited) # 示例图 graph = { 'A': ['B', 'C'], 'B': ['A', 'D', 'E'], 'C': ['A', 'F'], 'D': ['B'], 'E': ['B', 'F'], 'F': ['C', 'E'] } # 广度优先遍历 print('BFS:', end=' ') bfs(graph, 'A') print() # 深度优先遍历 print('DFS:', end=' ') dfs(graph, 'A') print() ``` 输出结果： ``` BFS: A B C D E F DFS: A B D E F C ``` 其中，`graph`是一个字典类型的图表示，键为节点，值为与该节点相邻的节点列表。`start`为遍历的起点节点。 ### 回答2： 图的广度优先遍历（BFS）和深度优先遍历（DFS）是两种常用的图遍历算法，下面是它们的代码实现： 广度优先遍历代码实现（BFS）： ``` def BFS(graph, start): visited = set() # 记录已访问过的节点 queue = [] # 使用队列来辅助实现BFS visited.add(start) queue.append(start) while queue: node = queue.pop(0) # 弹出队首节点 print(node, end=" ") # 访问节点 for neighbor in graph[node]: if neighbor not in visited: visited.add(neighbor) queue.append(neighbor) ``` 深度优先遍历代码实现（DFS）： ``` def DFS(graph, start, visited): visited.add(start) print(start, end=" ") # 访问节点 for neighbor in graph[start]: if neighbor not in visited: DFS(graph, neighbor, visited) ``` 在以上两种代码中，`graph`是图的表示方式，通常使用邻接表或邻接矩阵来表示；`start`是起始节点；`visited`是记录已访问节点的集合。 广度优先遍历使用队列来辅助遍历，从起始节点开始，将其加入队列并标记为已访问，然后从队列中弹出一个节点，访问它，并将其未访问过的邻居加入队列；一直重复这个过程，直到队列为空。 深度优先遍历使用递归方式实现，从起始节点开始，首先将其标记为已访问，然后递归地访问它的邻居节点，直到没有未访问的邻居节点为止，然后回溯到上一级节点，继续递归访问其未访问的邻居节点。这样一直递归下去，直到遍历完整个图。 BFS和DFS都可以遍历图的所有节点，并且每个节点仅被访问一次。 ### 回答3： 图的广度优先遍历（BFS）和深度优先遍历（DFS）是常用的图遍历算法。以下是它们的代码实现： 广度优先遍历（BFS）： 1. 建立一个队列，并将起始节点加入队列； 2. 创建一个visited列表，用于记录已经遍历过的节点； 3. 循环队列，直到队列为空： - 从队列中弹出一个节点，并将其标记为visited； - 遍历该节点的所有相邻节点： - 如果相邻节点未被visited，则将其加入队列； 4. 返回visited列表，即为广度优先遍历的结果。 下面是使用Python实现的广度优先遍历的代码： ``` def bfs(graph, start): visited = [] queue = [start] while queue: node = queue.pop(0) if node not in visited: visited.append(node) neighbors = graph[node] for neighbor in neighbors: queue.append(neighbor) return visited ``` 深度优先遍历（DFS）： 1. 创建一个visited列表，用于记录已经遍历过的节点； 2. 定义一个递归函数，用于进行深度优先遍历： - 将当前节点标记为visited； - 遍历当前节点的所有相邻节点： - 如果相邻节点未被visited，则递归调用该函数； 3. 在主函数中调用递归函数，并返回visited列表，即为深度优先遍历的结果。 下面是使用Python实现的深度优先遍历的代码： ``` def dfs(graph, start, visited): visited.append(start) neighbors = graph[start] for neighbor in neighbors: if neighbor not in visited: dfs(graph, neighbor, visited) def dfsTraversal(graph, start): visited = [] dfs(graph, start, visited) return visited ``` 需要注意的是，上述代码中的graph是以字典形式表示的图，其中键表示节点，值表示与该节点相邻的节点列表。此外，代码还需要预先定义起始节点start。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值