DFS算法专题(一)——二叉树中的深搜【回溯与剪枝的初步注入】

小丁爱养花2024-09-09 22:36

目录

1、DFS算法简介

2、算法实战应用【leetcode】

[2.1 计算布尔二叉树的值](#2.1 计算布尔二叉树的值)

[2.1.1 算法原理](#2.1.1 算法原理)

[2.1.2 算法代码](#2.1.2 算法代码)

[2.2 求根节点到叶节点数字之和](#2.2 求根节点到叶节点数字之和)

[2.2.1 算法原理](#2.2.1 算法原理)

[2.2.2 算法代码](#2.2.2 算法代码)

[2.3 二叉树剪枝](#2.3 二叉树剪枝)

[2.3.1 算法原理](#2.3.1 算法原理)

[2.3.2 算法代码](#2.3.2 算法代码)

[2.4 验证二叉搜索树](#2.4 验证二叉搜索树)

[2.4.1 算法原理](#2.4.1 算法原理)

[2.4.2 算法代码](#2.4.2 算法代码)

[2.5 二叉搜索树中第K小的元素](#2.5 二叉搜索树中第K小的元素)

[2.5.1 算法原理](#2.5.1 算法原理)

[2.5.2 算法代码](#2.5.2 算法代码)

[2.6 二叉树的所有路径](#2.6 二叉树的所有路径)

[2.6.1 算法原理](#2.6.1 算法原理)

[2.6.2 算法代码](#2.6.2 算法代码)

1、DFS算法简介

DFS，全称为 Depth First Traversal，深度优先遍历。

DFS算法是在**树或者图这样的数据结构中常用的一种遍历算法。**这个算法会尽可能深的搜索树或者图的分支，直到⼀条路径上的所有节点都被遍历完毕，然后再回溯到上一层，继续寻找另外一条路遍历。

简单来说，DFS就是：优先考虑深度，换句话说就是++一条路走到黑++，直到无路可走的情况下，才会选择回头，然后重新选择一条路。

在二叉树中，常见的深度优先遍历有：前序遍历、中序遍历以及后序遍历。

2、算法实战应用【leetcode】

2.1 计算布尔二叉树的值

. - 力扣（LeetCode）

2.1.1 算法原理

  1. 以宏观角度看待递归
  2. 后序遍历拿到最终值
  3. 函数头：boolean dfs(root)；
  4. 宏观思想-->函数体：返回左子树的布尔值，返回右子树的布尔值，根据当前根节点返回最终结果
  5. 函数出口：叶子节点，根据叶子节点数值返回布尔类型值

2.1.2 算法代码

java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean evaluateTree(TreeNode root) {
        if(root.left == null) 
        return root.val == 0 ? false : true;

        boolean left = evaluateTree(root.left);
        boolean right = evaluateTree(root.right);

        return root.val == 2 ? left || right : left && right;
    }
}

2.2 求根节点到叶节点数字之和

. - 力扣（LeetCode）

2.2.1 算法原理

  1. 递归的过程中，我们需要传递上层以及本层节点数字之和preSum
  2. 将上层以及本层节点数字之和preSum传递给当前根节点的左右子树
  3. 返回左右子树数值之和
  4. 函数出口：叶子节点。注意：要先将叶子节点的数值注入总和之中再返回

2.2.2 算法代码

java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int sumNumbers(TreeNode root) {
        return dfs(root, 0);
    }
    public int dfs(TreeNode root, int preSum) {
        preSum = preSum * 10 + root.val;
        if(root.left == null && root.right == null) return preSum;
        int ret = 0;
        //剪枝
        if(root.left != null) ret += dfs(root.left, preSum);
        if(root.right != null) ret += dfs(root.right, preSum);
        return ret;
    }
}

2.3 二叉树剪枝

. - 力扣（LeetCode）

2.3.1 算法原理

  1. 思想：后序遍历，当根节点的左右子树的所有值均为0时，才可删除当前树
  2. 从叶子节点开始判断，若其值为0则可删除
  3. 可被删除的节点返回null，父节点.left/right接收null，修改其父节点的指向
  4. 继续判断当前节点

2.3.2 算法代码

java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode pruneTree(TreeNode root) {
        if(root == null) return null;
        
        root.left = pruneTree(root.left);
        root.right = pruneTree(root.right);
        if(root.left == null && root.right == null && root.val == 0) return null;
        else return root;
    }
}

2.4 验证二叉搜索树

. - 力扣（LeetCode）

2.4.1 算法原理

本题所用思想：

  1. 全局变量 int prev = Long.MIN_VALUE；(记录上一个节点的值)
  2. 中序遍历(将当前根节点依次和prev比较，查看序列是否有序)
  3. 需当前节点的左子树与右子树均满足二叉搜索树，以及当前节点本身满足二叉搜索树，才能说明该树为二叉搜索树
  4. 若当前节点满足，则更新prev的值为当前节点的val值；若当前节点不满足，则返回false，再通过剪枝优化代码，使函数提前终止并返回false。

2.4.2 算法代码

java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    long prev = Long.MIN_VALUE;
    public boolean isValidBST(TreeNode root) {
    if(root == null) return true;

    boolean left = isValidBST(root.left);
    if(prev >= root.val) {
        return false;
    }
    prev = root.val;
    boolean right = isValidBST(root.right);

    return left && right;
    }
}

2.5 二叉搜索树中第K小的元素

. - 力扣（LeetCode）

2.5.1 算法原理

与上一题思想一致，因为是二叉搜索树，所以中序遍历是突破口：

  1. 设置两个全局变量：public int count+public int ret
  2. 中序遍历(通过有序序列查找目标值)
  3. 因为中序遍历得到的是一个有序序列，所以利用count计数，计到第k个数时，使用ret存入
  4. 得到目标值后，在通过剪枝优化函数，使递归返回

2.5.2 算法代码

java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int count;
    public int ret;
    public int kthSmallest(TreeNode root, int k) {
        count = k;
        dfs(root);
        return ret;
    }
    public void dfs(TreeNode root) {
        //count == 0 -> 剪枝
        if(root == null || count == 0) return;
        dfs(root.left);
        count--;
        if(count == 0) {
            ret = root.val;
            //剪枝
            return;
        }
        dfs(root.right);
    }
}

2.6 二叉树的所有路径

. - 力扣（LeetCode）

2.6.1 算法原理

本题使用思想：

  1. 设置全局变量：List<String> ret;
  2. 回溯 -> "恢复现场"
  3. 注意：本题不能使用全局变量path恢复现场，因为本层路径的修改会影响到上一层。解法：使用局部变量(函数传参)path，回溯到上一层时，函数会自动"恢复现场"。
  4. 剪枝 -> 优化代码

函数设计：

  • 函数头：void dfs(root,path);
  • 函数体：非叶子：root.val+"->" ；叶子：root.val + ret.add(path) + return(剪枝)
  • 函数出口 -> 剪枝处理

2.6.2 算法代码

java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    List<String> ret = new ArrayList<>();
    public List<String> binaryTreePaths(TreeNode root) {
        //path -> 记录路径
        //回溯 -> 函数自动"恢复现场"
        dfs(root, new StringBuffer());
        return ret;
    }
    public void dfs(TreeNode root, StringBuffer path_) {
        //保留上一层路径
        StringBuffer path = new StringBuffer(path_);
        path.append(root.val);
        if(root.left == null && root.right == null) {
            ret.add(path.toString());
            return;
        }
        path.append("->");
        //if -> 剪枝，省略函数出口
        if(root.left != null) dfs(root.left, path);
        if(root.right != null) dfs(root.right, path);
    }
}

++END++

相关推荐
QXH2000006 分钟前
数据结构—双向链表
c语言·数据结构·算法·链表
bluebonnet276 分钟前
【Rust练习】15.match 和 if let
开发语言·后端·rust
yueqingll21 分钟前
020、二级Java选择题综合知识点（持续更新版）
java·开发语言
旺小仔.25 分钟前
【数据结构篇】~排序（1）之插入排序
c语言·数据结构·算法·链表·性能优化·排序算法
计算机学姐38 分钟前
基于python+django+vue的在线学习资源推送系统
开发语言·vue.js·python·学习·django·pip·web3.py
A洛41 分钟前
Cloudflare Pages 部署 Next.js 应用教程
开发语言·github·nextjs·cloudflare·cloudflarepages
lly2024061 小时前
Rust 函数
开发语言
许野平1 小时前
Rust：深入浅出说一说 Error 类型
java·开发语言·rust·error
绎岚科技1 小时前
深度学习自编码器 - 随机编码器和解码器篇
人工智能·深度学习·算法·机器学习
jingling5551 小时前
后端开发刷题 | 数字字符串转化成IP地址
java·开发语言·javascript·算法
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）05Coze扣子平台完整体验和实践（附国内和国际版对比）06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07【经验分享】Ubuntu22.04安装微信(linux官方版)08苍穹外卖面试总结09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10Ubuntu24.04安装中文输入法