复习一下dfs和bfs 用java

【Java算法之dfs 与bfs详解】 Java算法之dfs 与bfs1. dfs1.1 递归1.2 非递归2. bfs2.1 常见两类问题 1. dfs 深度优先遍历(Depth First Search, 简称 DFS) 深度优先遍历各个节点,需要使用到栈(Stack)这种数据结构。Stack的特点是是先进后出,首先将右节点压入栈中,在将左节点压入栈中,这样出栈顺序就是先左节点再右节点。 DFS是图论里面的一种搜索算法,他可以由一个根节点出发,遍历所有的子节点,进而把图中所有的可以构成树的集合都搜索一遍,达到全局搜索的目的。所以很多问题都可以 阅读详情

dfs 和 bfs都是用来找从source 到 target的path的算法。

dfs用的是recursion,bfs则用queue。而且bfs可以找出shortest path。

/* tony
 * Apr 28, 2014
 * pathFind gives the edgeTo t from s
 * @pathFind the constructor
 */

public class pathFind{
	private boolean[] marked;
	private int[] edgeTo;
	private int[] distTo;
	//private final int s;
	
	public pathFind(Graph g, int s){
		//this.s = s;
		edgeTo = new int[g.V()];
		distTo = new int[g.V()];
		marked = new boolean[g.V()];
		dfs(g,s);
	}
	
	private void dfs(Graph g, int v){
		marked[v] = true;
		for(int w: g.adj(v)){
			if(!marked[w]){
				edgeTo[w] = v;
				distTo[w] = distTo[v]+1;
				dfs(g,w);
			}
		}
	}

	
	public boolean hasPathTo(int v){
		return marked[v];
	}
	
	
	// pathTo method return an interable value:
	public Iterable<Integer> pathTo(int v){
		if(!hasPathTo(v)){
			return null;
		}
		// else
		Stack<Integer> path = new Stack<Integer>();
		//for(int x = v; x!=s; x = edgeTo[x]){   // why !=s? because I am tracing 
											//back from the node to s
		int x;
		for(x = v; distTo[x]!=0; x = edgeTo[x]){
			path.push(x);
		}
		//path.push(s);
		path.push(x);
		return path;
	}
	
	public static void main(String[] args){
		In in = new In(args[0]);
		Graph g = new Graph(in);
		int s = Integer.parseInt(args[1]);
		pathFind dfs = new pathFind(g,s);
		StdOut.println("DFS path find with distTo output");
		
		for (int v = 0; v < g.V(); v++){
			if(dfs.hasPathTo(v)){
				StdOut.printf("%d to %d - (%d): ", s, v, dfs.distTo[v]);
				for(int x : dfs.pathTo(v)){
					if(x == s) StdOut.print(x);
					else	  StdOut.print("->" + x);
				}
				StdOut.println();
			}
		}
	}
}

这个是bfs:

/*
 * tony
 * Apr 26, 2014
 * BreathFirstPath from Algs4 part II week 1
 * dfs-----recursion----stack
 * bfs-----no recursion----queue
 */

public class BFSPath{
	private static final int INFINITY = Integer.MAX_VALUE;
	private boolean[] marked;
	private int[] edgeTo;
	private int[] distTo;
	
	
	/*
	 * compute the shortest path between a single source vertex
	 */
	public BFSPath(Graph G, int s){
		marked = new boolean[G.V()];
		edgeTo = new int[G.V()];
		distTo = new int[G.V()];
		bfs(G,s);
	}
	
	/*
	 * compute the shortest path between multiple source vertices
	 */
	public BFSPath(Graph G, Iterable<Integer> sources){
		marked = new boolean[G.V()];
		distTo = new int[G.V()];
		edgeTo = new int[G.V()];
		for(int v=0; v<G.V(); v++){
			distTo[v] = INFINITY;
		}
		bfs(G, sources);
	}
	
	// bfs from a single source
	private void bfs(Graph G, int s){
		Queue<Integer> q = new Queue<Integer>();
		for(int v = 0; v<G.V(); v++) distTo[v] = INFINITY;
		distTo[s] = 0;
		marked[s] = true;
		q.enqueue(s);
		
		while(!q.isEmpty()){
			int v = q.dequeue();
			for(int w : G.adj(v)){
				if(!marked[w]){
					edgeTo[w] = v;
					distTo[w] = distTo[v] + 1;
					marked[w] = true;
					q.enqueue(w);
				}
			}
		}
	}
	
	// bfs from multiple sources
	private void bfs(Graph G, Iterable<Integer> sources){
		Queue<Integer> q = new Queue<Integer>();
		for(int s: sources){
			marked[s] = true;
			distTo[s] = 0;
			q.enqueue(s);
		}
		while(!q.isEmpty()){
			int v = q.dequeue();
			for(int w: G.adj(v)){
				if(!marked[w]){
					marked[w] = true;
					distTo[w] = distTo[v]+1;
					edgeTo[w] = v;
					q.enqueue(w);
				}
			}
		}
	}
	
	public boolean hasPathTo(int w){
		return marked[w];
	}
	public int distTo(int w){
		return distTo[w];
	}
	
	public Iterable<Integer> pathTo(int v){
		if(!hasPathTo(v)) return null;
		Stack<Integer> path = new Stack<Integer>();
		int x;
		for(x = v; distTo[x]!= 0; x=edgeTo[x]){
			path.push(x);
		}
		path.push(x);
		return path;
	}
	
	/**
     * Unit tests the <tt>BreadthFirstPaths</tt> data type.
     */
    public static void main(String[] args) {
        In in = new In(args[0]);
        Graph G = new Graph(in);
        StdOut.println(G);
        StdOut.println("BFS path find output:    ");
        int s = Integer.parseInt(args[1]);
        BFSPath bfs = new BFSPath(G, s);

        for (int v = 0; v < G.V(); v++) {
            if (bfs.hasPathTo(v)) {
                StdOut.printf("%2d to %d (%2d):  ", s, v, bfs.distTo(v));
                for (int x : bfs.pathTo(v)) {
                    if (x == s) StdOut.print(x);
                    else        StdOut.print("->" + x);
                }
                StdOut.println();
            }

            else {
                StdOut.printf("%2d to %2d (-):  not connected\n", s, v);
            }

        }
    }

	
}

















这个是2个的输出:

6 vertices, 8 edges 
0: 2 1 5 
1: 0 2 
2: 0 1 3 4 
3: 5 4 2 
4: 3 2 
5: 3 0 


DFS path find with distTo output
0 to 0 - (0): 0
0 to 1 - (2): 0->2->1
0 to 2 - (1): 0->2
0 to 3 - (2): 0->2->3
0 to 4 - (3): 0->2->3->4
0 to 5 - (3): 0->2->3->5


BFS path find output:    
 0 to 0 ( 0):  0
 0 to 1 ( 1):  0->1
 0 to 2 ( 1):  0->2
 0 to 3 ( 2):  0->2->3
 0 to 4 ( 2):  0->2->4
 0 to 5 ( 1):  0->5


【Py/Java/C++三种语言OD2023C卷真题】20天拿下华为OD笔试之【DFS/BFS】2023C-精准核酸检测【欧弟算法】全网注释最详细分类最全的华为OD真题题解 有LeetCode算法/华为OD考试扣扣交流群可加可上全网独家的练习华子OD、大厂真题绿色聊天软件戳od1336了解算法冲刺训练。 阅读详情

相关推荐

Zemax物理光学实战:3分钟搞定高斯光束传播模拟(附菲涅尔局部分析技巧)

本文详细介绍了在Zemax中进行高斯光束传播模拟与菲涅尔局部分析的实战技巧。通过3分钟快速设置指南和参数解析,帮助光学工程师准确模拟激光光束特性,避免常见误区。特别分享了菲涅尔局部分析的关键技巧和传播参数优化策略,提升光学系统设计的精度与效率。

lambda的博客 805

BFS (Java) 广度优先搜索 简单介绍、模板、案例(一)

深度优先搜索DFS和广度优先搜索BFS是经常使用的搜索算法,在各类题目中都有广泛的应用。 深度优先搜索算法(英语:Depth-First-Search,DFS)是一种用于遍历或搜索树或图的算法。其过程简要来说是对每一个可能的分支路径深入到不能再深入为止,而且每个结点只能访问一次。 广度优先搜索算法(Breadth-First Search,缩写为 BFS),又称为宽度优先搜索,是一种图形搜索算法。简单的说,BFS 是从根结点开始,沿着树的宽度遍历树的结点。如果所有结点均被

weixin_45532984的博客 4293

利用 vivado实现加减法器的设计

本科计组实验:利用 vivado实现加减法器的设计

qq_52052302的博客 1万+

BFS(JAVA版讲解)

可以先refer to这篇C++版文章 广度优先搜索(Breadth First Search , BFS)遍历类似于树的按层次遍历的过程,则是以广度为第一关键词,当碰到岔道口时,总是先依次访问从该岔道口能直接到达的所有结点,然后再按这些结点被访问的顺序去依次访问它们能直接到达的所有结点,以此类推,直到所有结点都被访问为止。 广度优先搜索的整个算法过程很像一个队列,因此,广度优先搜索一般由...

长夜漫漫,无心睡眠 1万+

基于计算机视觉的Windows自动化工具openclaw-win:从原理到实战

计算机视觉与自动化技术正深刻改变人机交互方式,其核心在于让机器具备“感知-决策-执行”的能力。通过图像采集与处理算法,程序可以识别屏幕上的特定元素;结合模拟输入技术,便能自动执行点击、拖拽等操作,形成完整的自动化闭环。这一技术栈在软件测试、数据采集、重复性办公任务等领域具有重要价值,能够显著提升工作效率。开源项目openclaw-win正是这一理念的工程实践,它整合了图像识别与模拟操作模块,为开发者提供了一个研究自动化技术的具体样本。项目涉及模板匹配、坐标计算等关键技术点,并需处理屏幕适配、操作延迟等实际问

weixin_28745975的博客 334

企业微信微盘API权限避坑指南:为什么你的Python脚本无法获取文件列表?

本文深入解析了企业微信微盘API的权限模型,解释了为何即使使用超级管理员账号,Python脚本也可能因权限不足而无法获取文件列表。核心在于微盘API基于“应用身份”而非“用户身份”进行校验,应用只能访问自身创建的空间。文章提供了构建文件上传代理、利用事件回调等合规的替代方案,帮助企业实现高效数据同步。

weixin_29322553的博客 534

Java 广度优先搜索(Breadth-First Search,BFS)

我们从顶点 0 开始,BFS 算法首先将其放入 Visited 列表中,并将其所有相邻顶点放入堆栈中。接下来,我们访问队列前面的元素(即 1)并访问其相邻节点。顶点 2 在 4 中有一个未访问的相邻顶点,因此我们将其添加到队列的后面并访问位于队列前面的 3。队列中只剩下 4 个节点,因为 3 的唯一相邻节点(即 0)已经被访问过。BFS算法的时间复杂度用 的形式表示O(V + E),其中V是节点数,E 是边数。将不在访问列表中的添加到队列的后面。取出队列的最前面的项目并将其添加到访问列表中。

csdn_aspnet的专栏,请点击博客主页右上角三个点中的私信联系 2万+

还在用 RaiDrive/Rclone 挂载网盘?教您使用Windows 原生 WebDAV 丝滑直连 AList/Openlist,让你的网盘秒变本地硬盘!

网盘文件分散管理?😩 别再依赖第三方工具了!本文教你如何在 Windows 下,利用原生 WebDAV 功能,将 Openlist 网盘直接映射为本地硬盘!💻 操作简单,告别繁琐,让你的云端文件像本地文件一样丝滑!🚀 轻松实现高效管理,快来体验吧!

XiaoqiangClub的博客 2981

Java数据结构与算法----搜索篇(DFS与BFS)

DFS与BFS算法

stu_kk的博客 2652

YOLOv13涨点改进 | 全网独家创新、高效涨点改进篇 | CVPR 2024 | YOLOv13引入SHSA单头自注意力模块,减少冗余的多头注意力,轻量化改进,助力目标检测和图像分类任务高效涨点

本文提出了一种改进YOLOv13模型的新方法——SHSA(单头自注意力)模块,用于提升目标检测任务的计算效率和推理速度。SHSA通过简化多头注意力机制为单头结构,显著减少了计算冗余和内存占用。实验表明,该模块在保持精度的同时,在GPU、CPU和移动设备上分别实现了3.3倍、8.1倍和2.4倍的加速效果。文章详细介绍了SHSA的结构原理、核心代码实现方法,以及如何集成到YOLOv13的配置文件中。这种改进特别适合资源受限设备,为实时目标检测提供了更优的速度-精度平衡方案。

Ai缝合怪、助力小伙伴高效发论文 512

断层错动和近断层地震动联合作用下软岩隧洞衬砌损伤分析

摘要 本文提出了一种基于Python的软岩隧洞衬砌损伤分析系统,重点研究断层错动和近断层地震动的联合作用效应。系统采用有限元方法建立隧洞-围岩体系模型,通过非线性动力分析评估衬砌结构损伤。研究内容包括:1)建立考虑应变软化的软岩本构模型;2)基于位错理论模拟断层错动过程;3)合成具有速度脉冲效应的近断层地震动;4)开发完整的动力响应分析流程。结果表明,所提出的方法能有效评估软岩隧洞在复杂地质条件下的抗震性能,为工程设计提供理论依据。 关键词:软岩隧洞、断层错动、近断层地震动、损伤分析、Python、有限元法

max500600的博客 845

《算法从入门到入土系列》第一集 搜索专题(DFS与BFS)题目解析 + 练习题单(更新ing)

搜索专题(DFS与BFS) 从入门到入土 题目解析 + 练习题单搜索BFSAcWing 844. 走迷宫Flood Fill 算法AcWing 1097. 池塘计数AcWing 1098. 城堡问题AcWing 1106. 山峰和山谷最短路模型AcWing 1076. 迷宫问题(单源最短路)AcWing 188. 武士风度的牛LUOGU P1443 马的遍历多源BFSAcWing 173. 矩阵距离最小步数模型AcWing 1107. 魔板双端队列广搜AcWing 175. 电路维修双向广搜AcWing 1

ACM-ICPC 现役(铜牌) Codeforces Rating: 2172 4863

【openwrt-21.02】T750 openwrt 双系统说明及切换方法

高度集成的 T750 平台大幅减少组件数量,为产品设计者提供更小的尺寸和更低的功耗。T750 采用先进的 7nm 制程,高度集成 5G 调制解调器和四核 Arm CPU,提供较强的功能和配置,设备制造商得以打造精巧的高性能 CPE 产品,如固定无线接入(FWA)路由器和移动热点。3. preloader 加载并启动 A 系统,若 A 系统的任一启动阶段加载失败,preloader 将重新加载并启动 A 系统 3 次,若 3 次均失败,则自动切换至 B 系统,加载并启动 B 系统。A/B 系统切换流程如下。

wgl307293845的博客 1419

java实现二叉树的两种遍历方式,BFS和DFS

最近复习到了这个点,写点东西加强一下记忆吧 二叉树遍历 百度百科上是这么解释的: 所谓遍历(Traversal)是指沿着某条搜索路线,依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问 题。 遍历是二叉树上最重要的运算之一,是二叉树上进行其它运算之基础。 很明显,遍历也会有着不同的方式,这里我们就简单的讲讲BFS和DFS BFS(Breadth First Sear...

小哲的无何有镜 538

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

DFS深度优先搜索java

借着毕设又复习了一下数据结构的知识和课堂讲义 图的遍历 在图的遍历算法设计中,需要考虑三个问题: (1)访问的第一个顶点需要被指定; (2)避免遍历路径可能出现的死循环问题。 图中可能存在回路,且图的任一顶点都可能与其它顶点相通,在访问完某个顶点之后可能会沿着某些边又回到了曾经访问过的顶点。为了避免这种重复访问,可设置一个标志顶点是否被访问过的辅助数组 visited [ ]。 辅助数组visit...

升级打怪之路 501

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

2024年Java最全DFS和BFS总结和代码演示(详解),Mysql和Redis数据同步该怎么做

无论是哪家公司,都很重视Spring框架技术,重视基础,所以千万别小看任何知识。面试是一个双向选择的过程,不要抱着畏惧的心态去面试,不利于自己的发挥。同时看中的应该不止薪资,还要看你是不是真的喜欢这家公司,好了希望这篇文章对大家有帮助!本文已被CODING开源项目:【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友,可以点击这里获取=0 ){//表示已经访问过q.push(i);//将 i 入队// 非连通图的BFS遍历。

2401_84692226的博客 945

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

DFS 和 BFS 的做题感受

最近,很是不在状态啊。 第一,自从回家之后,很是膨胀,大概有十天时间没有更新过博客了,而且暑假学的东西虽然当时可能理解了,但是现在从头开始复习,各种不会,我的天呐,我是怎么了!!!!! 第二,开学了,自己能水的特点又出来了,各种水群,真的是太浪费时间和生命了啊!! 很尴尬,这种事情又没法控制,只能说,我就是一个大水比!!!!!!! 改,以后让人给我禁言了算了。 第三,刚刚开学,这学期不想逃

狮子淡泊名利 1869

2024-07-20[DFS][BFS]

return;//返回i>n;//起点位置//起点坐标dfs(1,1,1);//深度优先搜索cout

2401_85377283的博客 719

(Java)数据结构——图(第二节)DFS的实现

本博客是博主用于复习数据结构以及算法的博客,如果疏忽出现错误,还望各位指正。

m0_60631836的博客 581

算法复习dfs bfs

任何一个大于 $1$ 的自然数 $n$,总可以拆分成若干个小于 $n$ 的自然数之和。现在给你一个自然数 $n$,要求你求出 $n$ 的拆分成一些数字的和。对于全部的测试点,保证 $1 \leq x \leq n \leq 400$,$1 \leq y \leq m \leq 400$。有一个 $n \times m$ 的棋盘,在某个点 $(x, y)$ 上有一个马,要求你计算出马到达棋盘上任意一个点最少要走几步。数据保证,$2\leq n\le 8$。输入:待拆分的自然数 $n$。对于每个询问输出答案。

zt235的博客 1014

算法复习 - 广度优先遍历、深度优先遍历(BFS、DFS)

BinaryTreeNode.java /** * Created by apple on 16/6/18. */ public class BinaryTreeNode { private BinaryTreeNode leftNode; private BinaryTreeNode rightNode; private String root; public BinaryTr

pokerface_lx的博客 483

(Java)数据结构——图(第三节)BFS的实现

本博客是博主用于复习数据结构以及算法的博客,如果疏忽出现错误,还望各位指正。

m0_60631836的博客 972

leetcode刷题542. 01 矩阵(Java)DFS+BFS+DP

leetcode 542 01矩阵 DFS BFS DP Java 深度优先 广度优先 动态规划

Sueko的博客 479

【数据结构】图-图的遍历_深度优先遍历(动态图解、c++、java)

URLeisure的图的遍历_深度优先遍历“完美”复习资料。

扑腾的江鱼复习仓库 3542

Clone Graph leetcode java(DFS and BFS 基础)

题目: Clone an undirected graph. Each node in the graph contains a label and a list of its neighbors. OJ's undirected graph serialization: Nodes are labeled uniquely. We use # as a ...

weixin_33887443的博客 146

复习 dfs 一个有待提高的版本 17. Letter Combinations of a Phone Number

17. Letter Combinations of a Phone Number 最开始尝试用非递归结构写,想到表示是否访问写起来比较复杂与费空间,就改成递归结构了。这个版本有待优化。 import java.util.ArrayList; import java.util.List; public class Solution { public static void main

独钓寒江雪 387
上一篇: 段公子 Facebook
下一篇: 复习recursion
纯黑老白
博客等级 码龄18年 30粉丝 62原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值