图文详解两种算法:深度优先遍历(DFS)和广度优先遍历(BFS)
参考网址:图文详解两种算法:深度优先遍历(DFS)和广度优先遍历(BFS) - 51CTO.COM
深度优先遍历(Depth First Search, 简称 DFS) 与广度优先遍历(Breath First Search)是图论中两种非常重要的算法,生产上广泛用于拓扑排序,寻路(走迷宫),搜索引擎,爬虫等,也频繁出现在 leetcode,高频面试题中。
本文将会从以下几个方面来讲述深度优先遍历,广度优先遍历,相信大家看了肯定会有收获。
- 深度优先遍历,广度优先遍历简介
- 习题演练
- DFS,BFS 在搜索引擎中的应用
深度优先遍历,广度优先遍历简介
深度优先遍历
主要思路是从图中一个未访问的顶点 V 开始,沿着一条路一直走到底,然后从这条路尽头的节点回退到上一个节点,再从另一条路开始走到底...,不断递归重复此过程,直到所有的顶点都遍历完成,它的特点是不撞南墙不回头,先走完一条路,再换一条路继续走。
树是图的一种特例(连通无环的图就是树),接下来我们来看看树用深度优先遍历该怎么遍历。
1、我们从根节点 1 开始遍历,它相邻的节点有 2,3,4,先遍历节点 2,再遍历 2 的子节点 5,然后再遍历 5 的子节点 9。
2、上图中一条路已经走到底了(9是叶子节点,再无可遍历的节点),此时就从 9 回退到上一个节点 5,看下节点 5 是否还有除 9 以外的节点,没有继续回退到 2,2 也没有除 5 以外的节点,回退到 1,1 有除 2 以外的节点 3,所以从节点 3 开始进行深度优先遍历,如下:
3、同理从 10 开始往上回溯到 6, 6 没有除 10 以外的子节点,再往上回溯,发现 3 有除 6 以外的子点 7,所以此时会遍历 7。
3、从 7 往上回溯到 3, 1,发现 1 还有节点 4 未遍历,所以此时沿着 4, 8 进行遍历,这样就遍历完成了。
完整的节点的遍历顺序如下(节点上的的蓝色数字代表):
相信大家看到以上的遍历不难发现这就是树的前序遍历,实际上不管是前序遍历,还是中序遍历,亦或是后序遍历,都属于深度优先遍历。
那么深度优先遍历该怎么实现呢,有递归和非递归两种表现形式,接下来我们以二叉树为例来看下如何分别用递归和非递归来实现深度优先遍历。
1、递归实现
递归实现比较简单,由于是前序遍历,所以我们依次遍历当前节点,左节点,右节点即可,对于左右节点来说,依次遍历它们的左右节点即可,依此不断递归下去,直到叶节点(递归终止条件),代码如下:
- public class Solution {
- private static class Node {
- /**
- * 节点值
- */
- public int value;
- /**
- * 左节点
- */
- public Node left;
- /**
- * 右节点
- */
- public Node right;
- public Node(int value, Node left, Node right) {
- this.value = value;
- this.left = left;
- this.right = right;
- }
- }
- public static void dfs(Node treeNode) {
- if (treeNode == null) {
- return;
- }
- // 遍历节点
- process(treeNode)
- // 遍历左节点
- dfs(treeNode.left);
- // 遍历右节点
- dfs(treeNode.right);
- }
- }
递归的表达性很好,也很容易理解,不过如果层级过深,很容易导致栈溢出。所以我们重点看下非递归实现。
2、非递归实现
仔细观察深度优先遍历的特点,对二叉树来说,由于是先序遍历(先遍历当前节点,再遍历左节点,再遍历右节点),所以我们有如下思路:
对于每个节点来说,先遍历当前节点,然后把右节点压栈,再压左节点(这样弹栈的时候会先拿到左节点遍历,符合深度优先遍历要求)。
弹栈,拿到栈顶的节点,如果节点不为空,重复步骤 1, 如果为空,结束遍历。
我们以以下二叉树为例来看下如何用栈来实现 DFS。
整体动图如下:
整体思路还是比较清晰的,使用栈来将要遍历的节点压栈,然后出栈后检查此节点是否还有未遍历的节点,有的话压栈,没有的话不断回溯(出栈),有了思路,不难写出如下用栈实现的二叉树的深度优先遍历代码:
- /**
- * 使用栈来实现 dfs
- * @param root
- */
- public static void dfsWithStack(Node root) {
- if (root == null) {
- return;
- }
- Stack<Node> stack = new Stack<>();
- // 先把根节点压栈
- stack.push(root);
- while (!stack.isEmpty()) {
- Node treeNode = stack.pop();
- // 遍历节点
- process(treeNode)
- // 先压右节点
- if (treeNode.right != null) {
- stack.push(treeNode.right);
- }
- // 再压左节点
- if (treeNode.left != null) {
- stack.push(treeNode.left);
- }
- }
- }
可以看到用栈实现深度优先遍历其实代码也不复杂,而且也不用担心递归那样层级过深导致的栈溢出问题。
广度优先遍历
广度优先遍历,指的是从图的一个未遍历的节点出发,先遍历这个节点的相邻节点,再依次遍历每个相邻节点的相邻节点。
上文所述树的广度优先遍历动图如下,每个节点的值即为它们的遍历顺序。所以广度优先遍历也叫层序遍历,先遍历第一层(节点 1),再遍历第二层(节点 2,3,4),第三层(5,6,7,8),第四层(9,10)。
深度优先遍历用的是栈,而广度优先遍历要用队列来实现,我们以下图二叉树为例来看看如何用队列来实现广度优先遍历。
动图如下:
相信看了以上动图,不难写出如下代码:
- /**
- * 使用队列实现 bfs
- * @param root
- */
- private static void bfs(Node root) {
- if (root == null) {
- return;
- }
- Queue<Node> stack = new LinkedList<>();
- stack.add(root);
- while (!stack.isEmpty()) {
- Node node = stack.poll();
- System.out.println("value = " + node.value);
- Node left = node.left;
- if (left != null) {
- stack.add(left);
- }
- Node right = node.right;
- if (right != null) {
- stack.add(right);
- }
- }
- }
习题演练
接下来我们来看看在 leetcode 中出现的一些使用 DFS,BFS 来解题的题目:
- leetcode 104,111: 给定一个二叉树,找出其最大/最小深度。
例如:给定二叉树 [3,9,20,null,null,15,7],
- 3
- / \
- 9 20
- / \
- 15 7
则它的最小深度 2,最大深度 3。
解题思路:这题比较简单,只不过是深度优先遍历的一种变形,只要递归求出左右子树的最大/最小深度即可,深度怎么求,每递归调用一次函数,深度加一。不难写出如下代码:
- /**
- * leetcode 104: 求树的最大深度
- * @param node
- * @return
- */
- public static int getMaxDepth(Node node) {
- if (node == null) {
- return 0;
- }
- int leftDepth = getMaxDepth(node.left) + 1;
- int rightDepth = getMaxDepth(node.right) + 1;
- return Math.max(leftDepth, rightDepth);
- }
- /**
- * leetcode 111: 求树的最小深度
- * @param node
- * @return
- */
- public static int getMinDepth(Node node) {
- if (node == null) {
- return 0;
- }
- int leftDepth = getMinDepth(node.left) + 1;
- int rightDepth = getMinDepth(node.right) + 1;
- return Math.min(leftDepth, rightDepth);
- }
leetcode 102: 给你一个二叉树,请你返回其按层序遍历得到的节点值。(即逐层地,从左到右访问所有节点)。示例,给定二叉树:[3,9,20,null,null,15,7]。
- 3
- / \
- 9 20
- / \
- 15 7
返回其层次遍历结果:
- [
- [3],
- [9,20],
- [15,7]
- ]
解题思路:显然这道题是广度优先遍历的变种,只需要在广度优先遍历的过程中,把每一层的节点都添加到同一个数组中即可,问题的关键在于遍历同一层节点前,必须事先算出同一层的节点个数有多少(即队列已有元素个数),因为 BFS 用的是队列来实现的,遍历过程中会不断把左右子节点入队,这一点切记!动图如下:
根据以上动图思路不难得出代码如下:
Java 代码
- /**
- * leetcdoe 102: 二叉树的层序遍历, 使用 bfs
- * @param root
- */
- private static List<List<Integer>> bfsWithBinaryTreeLevelOrderTraversal(Node root) {
- if (root == null) {
- // 根节点为空,说明二叉树不存在,直接返回空数组
- return Arrays.asList();
- }
- // 最终的层序遍历结果
- List<List<Integer>> result = new ArrayList<>();
- Queue<Node> queue = new LinkedList<>();
- queue.offer(root);
- while (!queue.isEmpty()) {
- // 记录每一层
- List<Integer> level = new ArrayList<>();
- int levelNum = queue.size();
- // 遍历当前层的节点
- for (int i = 0; i < levelNum; i++) {
- Node node = queue.poll();
- // 队首节点的左右子节点入队,由于 levelNum 是在入队前算的,所以入队的左右节点并不会在当前层被遍历到
- if (node.left != null) {
- queue.add(node.left);
- }
- if (node.right != null) {
- queue.add(node.right);
- }
- level.add(node.value);
- }
- result.add(level);
- }
- return result;
- }
Python 代码
- class Solution:
- def levelOrder(self, root):
- """
- :type root: TreeNode
- :rtype: List[List[int]]
- """
- res = [] #嵌套列表,保存最终结果
- if root is None:
- return res
- from collections import deque
- que = deque([root]) #队列,保存待处理的节点
- while len(que)!=0:
- lev = [] #列表,保存该层的节点的值
- thislevel = len(que) #该层节点个数
- while thislevel!=0:
- head = que.popleft() #弹出队首节点
- #队首节点的左右孩子入队
- if head.left is not None:
- que.append(head.left)
- if head.right is not None:
- que.append(head.right)
- lev.append(head.val) #队首节点的值压入本层
- thislevel-=1
- res.append(lev)
- return res
这题用 BFS 是显而易见的,但其实也可以用 DFS, 如果在面试中能用 DFS 来处理,会是一个比较大的亮点。
用 DFS 怎么处理呢,我们知道, DFS 可以用递归来实现,其实只要在递归函数上加上一个「层」的变量即可,只要节点属于这一层,则把这个节点放入相当层的数组里,代码如下:
- private static final List<List<Integer>> TRAVERSAL_LIST = new ArrayList<>();
- /**
- * leetcdoe 102: 二叉树的层序遍历, 使用 dfs
- * @param root
- * @return
- */
- private static void dfs(Node root, int level) {
- if (root == null) {
- return;
- }
- if (TRAVERSAL_LIST.size() < level + 1) {
- TRAVERSAL_LIST.add(new ArrayList<>());
- }
- List<Integer> levelList = TRAVERSAL_LIST.get(level);
- levelList.add(root.value);
- // 遍历左结点
- dfs(root.left, level + 1);
- // 遍历右结点
- dfs(root.right, level + 1);
- }
DFS,BFS 在搜索引擎中的应用我们几乎每天都在 Google, Baidu 这些搜索引擎,那大家知道这些搜索引擎是怎么工作的吗,简单来说有三步:
1、网页抓取
搜索引擎通过爬虫将网页爬取,获得页面 HTML 代码存入数据库中
2、预处理
索引程序对抓取来的页面数据进行文字提取,中文分词,(倒排)索引等处理,以备排名程序使用
3、排名
用户输入关键词后,排名程序调用索引数据库数据,计算相关性,然后按一定格式生成搜索结果页面。
我们重点看下第一步,网页抓取。
这一步的大致操作如下:给爬虫分配一组起始的网页,我们知道网页里其实也包含了很多超链接,爬虫爬取一个网页后,解析提取出这个网页里的所有超链接,再依次爬取出这些超链接,再提取网页超链接。。。,如此不断重复就能不断根据超链接提取网页。如下图示:
如上所示,最终构成了一张图,于是问题就转化为了如何遍历这张图,显然可以用深度优先或广度优先的方式来遍历。
如果是广度优先遍历,先依次爬取第一层的起始网页,再依次爬取每个网页里的超链接,如果是深度优先遍历,先爬取起始网页 1,再爬取此网页里的链接...,爬取完之后,再爬取起始网页 2...
实际上爬虫是深度优先与广度优先两种策略一起用的,比如在起始网页里,有些网页比较重要(权重较高),那就先对这个网页做深度优先遍历,遍历完之后再对其他(权重一样的)起始网页做广度优先遍历。
总结
DFS 和 BFS 是非常重要的两种算法,大家一定要掌握,本文为了方便讲解,只对树做了 DFS,BFS,大家可以试试如果用图的话该怎么写代码,原理其实也是一样,只不过图和树两者的表示形式不同而已,DFS 一般是解决连通性问题,而 BFS 一般是解决最短路径问题,之后有机会我们会一起来学习下并查集,Dijkstra, Prism 算法等,敬请期待!
图文详解两种算法:深度优先遍历(DFS)和广度优先遍历(BFS)的更多相关文章
- 深度优先搜索DFS和广度优先搜索BFS简单解析(新手向)
深度优先搜索DFS和广度优先搜索BFS简单解析 与树的遍历类似,图的遍历要求从某一点出发,每个点仅被访问一次,这个过程就是图的遍历.图的遍历常用的有深度优先搜索和广度优先搜索,这两者对于有向图和无向图 ...
- 深度优先搜索DFS和广度优先搜索BFS简单解析
转自:https://www.cnblogs.com/FZfangzheng/p/8529132.html 深度优先搜索DFS和广度优先搜索BFS简单解析 与树的遍历类似,图的遍历要求从某一点出发,每 ...
- 图的 储存 深度优先(DFS)广度优先(BFS)遍历
图遍历的概念: 从图中某顶点出发访遍图中每个顶点,且每个顶点仅访问一次,此过程称为图的遍历(Traversing Graph).图的遍历算法是求解图的连通性问题.拓扑排序和求关键路径等算法的基础.图的 ...
- 图的深度优先遍历(DFS)和广度优先遍历(BFS)
body, table{font-family: 微软雅黑; font-size: 13.5pt} table{border-collapse: collapse; border: solid gra ...
- 图的深度优先搜索(DFS)和广度优先搜索(BFS)算法
深度优先(DFS) 深度优先遍历,从初始访问结点出发,我们知道初始访问结点可能有多个邻接结点,深度优先遍历的策略就是首先访问第一个邻接结点,然后再以这个被访问的邻接结点作为初始结点,访问它的第一个邻接 ...
- 图的深度优先遍历(DFS)和广度优先遍历(BFS)算法分析
1. 深度优先遍历 深度优先遍历(Depth First Search)的主要思想是: 1.首先以一个未被访问过的顶点作为起始顶点,沿当前顶点的边走到未访问过的顶点: 2.当没有未访问过的顶点时,则回 ...
- Asp.Net 中Grid详解两种方法使用LigerUI加载数据库数据填充数据分页
1.关于LigerUI: LigerUI 是基于jQuery 的UI框架,其核心设计目标是快速开发.使用简单.功能强大.轻量级.易扩展.简单而又强大,致力于快速打造Web前端界面解决方案,可以应用于. ...
- 【C++】基于邻接矩阵的图的深度优先遍历(DFS)和广度优先遍历(BFS)
写在前面:本博客为本人原创,严禁任何形式的转载!本博客只允许放在博客园(.cnblogs.com),如果您在其他网站看到这篇博文,请通过下面这个唯一的合法链接转到原文! 本博客全网唯一合法URL:ht ...
- 深度优先搜索DFS和广度优先搜索BFS
DFS简介 深度优先搜索,一般会设置一个数组visited记录每个顶点的访问状态,初始状态图中所有顶点均未被访问,从某个未被访问过的顶点开始按照某个原则一直往深处访问,访问的过程中随时更新数组visi ...
随机推荐
- java基础---java8 新特性
1. 函数式接口 函数式接口主要指只包含一个抽象方法的接口,如:java.lang.Runnable(java1.0).java.util.Comparator接口(java1.4)等. Java8提 ...
- Linux 之 usermod
usermod [选项] 登录名 usermod用于修改用户基本信息 -d 修改用户的主目录,与-m选项一起使用 -d和-m要联合使用,否则修改的用户有问题 -g,--gid 修改用户组,该用户组是必 ...
- 从sql2008导入表结构及数据到mysql
打开navicat for mysql连接mysqlcreate database lianxi刷新,双击lianxi,双击"表"点击右边的"导入向导"选择&q ...
- c++中的对象模型
1 对象模型的前世 类在c++编译器内部可以理解成结构体,所以在对象模型分析时,我们可以把 class 当作一种特殊的 struct: 1)在内存中 class 可以看作是普通成员变量的集合: 2) ...
- MapReduce处理数据1
学了一段时间的hadoop了,一直没有什么正经练手的机会,今天老师给了一个课堂测试来进行练手,正好试一下. 项目已上传至github:https://github.com/yandashan/MapR ...
- sshd_config详解
# $OpenBSD: sshd_config,v 1.101 2017/03/14 07:19:07 djm Exp $ # This is the sshd server system-wide ...
- springboot-4-CRUD开发实战
流程: 创建项目,勾选基本的几个开发工具还有webstarter 再创建包(service,control,config,dao,pojo) 再前往https://www.webjars.org/,选 ...
- 网络损伤仪WANsim中的时延的不同模型
网络损伤仪WANsim中的3种时延模型 时延指的是报文从网络的一端到达另一端所花费的时间. 网络损伤仪WANsim中为用户提供了3种时延损伤的模型.常量模型.均匀分布.正态分布. 这3种模型按照各自的 ...
- vulnhub-DC:2靶机渗透记录
准备工作 在vulnhub官网下载DC:1靶机https://www.vulnhub.com/entry/dc-2,311/ 导入到vmware 打开kali准备进行渗透(ip:192.168.200 ...
- 第一篇 -- Jmeter的安装下载
参考链接:https://blog.csdn.net/wust_lh/article/details/86095924 本篇介绍的是在Windows下安装Jmeter. 一.下载Jmeter 官网下载 ...