从三道leetcode掌握深度优先搜索(DFS)

·  阅读 209

前言

无论在算法面试还是刷题中,深度优先搜索(DFS)和广度优先搜索(BFS)都是一个绕不过去的坎。不同于数组的从左至右遍历,循环常用于一维数据结构的遍历。而DFSBFS则常用于多维数据结构的遍历,最常见的莫过于嵌套结构的多叉树了。

image.png

递归

我们先看看什么是递归

递归(英語:Recursion),又译为递回,在数学与计算机科学中,是指在函数的定义中使用函数自身的方法。

递归的概念很简单,就是指函数中调用函数本身,形成不断重复的调用。递归可以帮助我们将大问题化解为小问题,通过小问题的解来组成大问题的解。

image.png

我们来看个经典的递归运用斐波那契数列

斐波那契数,通常用 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实际是利用递归来实现的,所以前面讲了半天的递归。

现在才开始进入今天的主题,先来看看什么是深度优先搜索

形象点说深度优先搜索就是一条路走到黑不撞南墙不回头的递归搜索

以多叉树的搜索为例

image.png

  1. 从A开始,发现有子节点B,B继续发现有子节点E,所以第一条搜索路径是A -> B -> E

  2. E回退到B,发现B还有未搜索的子节点F,F继续发现子节点I,所以第二条搜索路径是F -> I

  3. 同理,继续回退及搜索,最后形成路径 A -> B -> E -> F -> I -> C -> D -> G -> J -> K -> H

知道DFS是什么后,我们通过几道leetcode题来掌握DFS

1.二叉树的前序遍历

我们先来看个最简单的二叉树遍历

提示:前序遍历是对于任一个节点 node 来说,搜索先后顺序为 node -> node.left -> node.right

leetcode-144

给你二叉树的根节点 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.合并二叉树

leetcode-617

给定两个二叉树,想象当你将它们中的一个覆盖到另一个上时,两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠,那么将他们的值相加作为节点合并后的新值,否则不为NULL 的节点将直接作为新二叉树的节点。

示例1:

image.png

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.岛屿的最大面积

前面都是树结构的数据,我们来看看一个二维数组的搜索。

leetcode-695

给你一个大小为 m x n 的二进制矩阵 grid 。

岛屿是由一些相邻的1(代表土地) 构成的组合,这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设grid 的四个边缘都被 0(代表水)包围着。

岛屿的面积是岛上值为 1 的单元格的数目。

计算并返回 grid 中最大的岛屿面积。如果没有岛屿,则返回面积为 0 。

image.png

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
};
复制代码

总结

我们来总结下今天的知识点

  1. 递归是指函数调用本身

  2. DFSBFS实际是遍历方法,只不过其遍历的数据类型是树或图或其它多维数据结构

  3. DFS是递归算法的一种,通过优先解答某一子问题,子子问题的来实现深度优先

  4. 使用DFS需要注意

  • 函数要有出口,防止无限递归,出口可以是答案也可以是不符合条件的剪枝
分类:
前端
分类:
前端