前言
无论在算法面试还是刷题中,深度优先搜索(DFS)和广度优先搜索(BFS)都是一个绕不过去的坎。不同于数组的从左至右遍历,循环常用于一维数据结构的遍历。而DFS
和BFS
则常用于多维数据结构的遍历,最常见的莫过于嵌套结构的多叉树
了。
递归
我们先看看什么是递归
递归(英語:Recursion),又译为递回,在数学与计算机科学中,是指在函数的定义中使用函数自身的方法。
递归的概念很简单,就是指函数中调用函数本身,形成不断重复的调用。递归可以帮助我们将大问题化解为小问题,通过小问题的解来组成大问题的解。
我们来看个经典的递归运用斐波那契数列
斐波那契数,通常用 F(n) 表示,形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始,后面的每一项数字都是前面两项数字的和。
现在我们来利用递归实现F(n)
吧
const F = (n) => {
// 小问题直接解决
if (n === 0) return 0
if (n === 1) return 1
// 把大问题化解为小问题
// 我们只需要将问题分解为小问题F(n - 1)和F(n - 2)
// 不用关心F(n - 1)和F(n -2)的求解过程
// 事实上只要n-1和n-2大于1就会一直拆解问题
// 直到遇到已经的0和1的解
return F(n - 1) + F(n - 2)
}
DFS
因为DFS
实际是利用递归来实现的,所以前面讲了半天的递归。
现在才开始进入今天的主题,先来看看什么是深度优先搜索
形象点说深度优先搜索就是
一条路走到黑
,不撞南墙不回头
的递归搜索
以多叉树的搜索为例
-
从A开始,发现有子节点B,B继续发现有子节点E,所以第一条搜索路径是
A -> B -> E
-
E回退到B,发现B还有未搜索的子节点F,F继续发现子节点I,所以第二条搜索路径是
F -> I
-
同理,继续回退及搜索,最后形成路径
A -> B -> E -> F -> I -> C -> D -> G -> J -> K -> H
知道DFS
是什么后,我们通过几道leetcode题来掌握DFS
1.二叉树的前序遍历
我们先来看个最简单的二叉树遍历
提示:前序遍历是对于任一个节点
node
来说,搜索先后顺序为node -> node.left -> node.right
给你二叉树的根节点 root ,返回它节点值的 前序 遍历。
// 图片
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {number[]}
*/
var preorderTraversal = function(root) {
const ans = []
if (!root) return ans
// 实现DFS
const dfs = (node) => {
// 在搜索过程中往答案中加入当前节点值
ans.push(node.val)
// 递归的出口为当前节点没有左子节点和右子节点
// 递归搜索左子节点
if (node.left) {
dfs(node.left)
}
// 递归搜索右子节点
if (node.right) {
dfs(node.right)
}
}
dfs(root)
return ans
};
2.合并二叉树
给定两个二叉树,想象当你将它们中的一个覆盖到另一个上时,两个二叉树的一些节点便会重叠。
你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠,那么将他们的值相加作为节点合并后的新值,否则不为NULL 的节点将直接作为新二叉树的节点。
示例1:
var mergeTrees = function(root1, root2) {
// 递归的一个重要逻辑就是要定义出口防止无限递归
// 下面的条件判断可以理解为出口
// 需要注意的是,出口可能是解
// 或者是不符条件的终止,我们将不符条件的终止叫做剪枝
if (!root1 && !root2) {
return null
}
if (root1 && !root2) {
return root1
}
if (!root1 && root2) {
return root2
}
// 如果问题还没被分解为最小问题
// 则需要再次分解成子问题
// 子问题的求解顺序则决定我们是使用DFS还是BFS
const node = new TreeNode(root1.val + root2.val)
// 我们在这先求解node.left
// 也就是会对root1.left和root2.left进行合并
// 当root1.left和root2.left仍然不是最小子问题时会继续往下递归调用mergeTrees
// 所以这是一种持续深入的递归求解模式,我们称其为DFS
node.left = mergeTrees(root1.left, root2.left)
// 当执行到右子节点时,左子节点及左子节点的后代实际都已经完成合并
node.right = mergeTrees(root1.right, root2.right)
return node;
};
3.岛屿的最大面积
前面都是树结构的数据,我们来看看一个二维数组的搜索。
给你一个大小为 m x n 的二进制矩阵 grid 。
岛屿是由一些相邻的1(代表土地) 构成的组合,这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设grid 的四个边缘都被 0(代表水)包围着。
岛屿的面积是岛上值为 1 的单元格的数目。
计算并返回 grid 中最大的岛屿面积。如果没有岛屿,则返回面积为 0 。
var maxAreaOfIsland = function(grid) {
// 初始化m/n用于计算边界
const m = grid.length
const n = grid[0].length
// 初始答案0
let ans = 0
// dfs函数
const getGrid = (row, col) => {
let count = 0
// 出口条件当前格子为0
if (grid[row][col] === 1) {
// 这边可以重点注意下
// 搜索过的格子置为0防止重复搜索
grid[row][col] = 0
count++
// 先搜索某一方向
// 直到遇到出口为止
// 所以当前搜索模式为深度优先搜索DFS
if (row > 0) {
count += getGrid(row - 1, col)
}
if (row + 1 < m) {
count += getGrid(row + 1, col)
}
if (col > 0) {
count += getGrid(row, col - 1)
}
if (col + 1 < n) {
count += getGrid(row, col + 1)
}
}
return count
}
// 不同于于树结构有根节点
// 对于二维数组来说没有根节点
// 所以我们需要遍历使用每个节点来进行上下左右的搜索
for (let i = 0; i < m; i++) {
for (let j = 0; j < n; j++) {
if (grid[i][j] === 1) {
// 搜索更新最大值
ans = Math.max(getGrid(i, j), ans)
}
}
}
return ans
};
总结
我们来总结下今天的知识点
-
递归是指函数调用本身
-
DFS
和BFS
实际是遍历方法,只不过其遍历的数据类型是树或图或其它多维数据结构 -
DFS
是递归算法的一种,通过优先解答某一子问题,子子问题的来实现深度优先 -
使用
DFS
需要注意
- 函数要有出口,防止无限递归,出口可以是答案也可以是不符合条件的剪枝