【DFS算法】二叉树中的深搜

最新推荐文章于 2024-08-22 17:27:46 发布

Y_3_7

最新推荐文章于 2024-08-22 17:27:46 发布

阅读量764

点赞数 31

分类专栏：算法文章标签：深度优先算法网络学习方法 leetcode 职场和发展

本文链接：https://blog.csdn.net/Y_1215/article/details/138869178

版权

算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇

二叉树中的深搜

🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇

1. 计算布尔⼆叉树的值（medium）

2. 求根节点到叶节点数字之和（medium）

前言

深度优先遍历（DFS，全称为DepthFirstTraversal），是我们树或者图这样的数据结构中常⽤的 ⼀种遍历算法。这个算法会尽可能深的搜索树或者图的分⽀，直到⼀条路径上的所有节点都被遍历完毕，然后再回溯到上⼀层，继续找⼀条路遍历。

在⼆叉树中，常⻅的深度优先遍历为：前序遍历、中序遍历以及后序遍历。

因为树的定义本⾝就是递归定义，因此采⽤递归的⽅法去实现树的三种遍历不仅容易理解⽽且代码很简洁。并且前中后序三种遍历的唯⼀区别就是访问根节点的时机不同，在做题的时候，选择⼀个适当的遍历顺序，对于算法的理解是⾮常有帮助的。

1. 计算布尔⼆叉树的值（medium）

题目链接：2331. 计算布尔二叉树的值 - 力扣（LeetCode）

算法思路：

本题可以被解释为：

1. 对于规模为n的问题，需要求得当前节点值。

2. 节点值不为0或1时，规模为n的问题可以被拆分为规模为n-1的⼦问题：

a. 所有⼦节点的值；

b. 通过⼦节点的值运算出当前节点值。

3. 当问题的规模变为n=1时，即叶⼦节点的值为0或1，我们可以直接获取当前节点值为0或1。

代码实现：

/**
 * 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) {
    /*  本题可以被解释为：
1. 对于规模为n的问题，需要求得当前节点值。
2. 节点值不为0或1时，规模为n的问题可以被拆分为规模为n-1的⼦问题：
a. 所有⼦节点的值；
b. 通过⼦节点的值运算出当前节点值。
3. 当问题的规模变为n=1时，即叶⼦节点的值为0或1，我们可以直接获取当前节点值为0或1。*/
    if(root.left == null &&root.right==null){
        return root.val == 1 ;
    }
    return root.val == 2 ? evaluateTree(root.left) | evaluateTree(root.right) :
    evaluateTree(root.left) & evaluateTree(root.right);
    }
}

2. 求根节点到叶节点数字之和（medium）

题目链接：129. 求根节点到叶节点数字之和 - 力扣（LeetCode）

算法思路：

在前序遍历的过程中，我们可以往左右⼦树传递信息，并且在回溯时得到左右⼦树的返回值。递归函数可以帮我们完成两件事：

1. 将⽗节点的数字与当前节点的信息整合到⼀起，计算出当前节点的数字，然后传递到下⼀层进⾏递归；

2. 当遇到叶⼦节点的时候，就不再向下传递信息，⽽是将整合的结果向上⼀直回溯到根节点。在递归结束时，根节点需要返回的值也就被更新为了整棵树的数字和。

代码实现：

/**
 * 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) {
/*
在前序遍历的过程中，我们可以往左右⼦树传递信息，并且在回溯时得到左右⼦树的返回值。递归函
数可以帮我们完成两件事：
1. 将⽗节点的数字与当前节点的信息整合到⼀起，计算出当前节点的数字，然后传递到下⼀层进⾏递
归；
2. 当遇到叶⼦节点的时候，就不再向下传递信息，⽽是将整合的结果向上⼀直回溯到根节点。
在递归结束时，根节点需要返回的值也就被更新为了整棵树的数字和。*/
      return dfs(root,0);
    }
    public static 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.right!=null){
            ret+=dfs(root.right,preSum);
        }
        if(root.left!=null){
            ret+=dfs(root.left,preSum);
        }
       
        return ret;
    }
}

3. ⼆叉树剪枝（medium）

题目链接:814. 二叉树剪枝 - 力扣（LeetCode）

算法原理:

递归函数设计: void dfs(TreeNode*& root)

1．返回值:无;
2．参数:当前需要处理的节点;
3．函数作用:判断当前节点是否需要删除，若需要删除，则删除当前节点。
后序遍历的主要流程:
1．递归出口:当传入节点为空时，不做任何处理;

2．递归处理左子树;
3．递归处理右子树;
4. 处理当前节点:判断该节点是否为叶子节点(即左右子节点均被删除，当前节点成为叶子节点),
并且节点的值为0∶
a.如果是，就删除掉;
b.如果不是，就不做任何处理。

代码实现:

/**
 * 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){
        //如果为叶子节点且为0就删除 返回null
        return null;
     }
     return root;
    }
}

4. 验证⼆叉搜索树（medium）

题目链接:98. 验证二叉搜索树 - 力扣（LeetCode）

算法原理 :

如果⼀棵树是⼆叉搜索树，那么它的中序遍历的结果⼀定是⼀个严格递增的序列。因此，我们可以初始化⼀个⽆穷⼩的全区变量，⽤来记录中序遍历过程中的前驱结点。那么就可以在中序遍历的过程中，先判断是否和前驱结点构成递增序列，然后修改前驱结点为当前结点，传⼊下⼀层的递归中。

1.初始化一个全局的变量prev，用来记录中序遍历过程中的前驱结点的 val;2.中序遍历的递归函数中:
a.设置递归出口:root == nullptr的时候，返回true;b.先递归判断左子树是否是二叉搜索树，用retleft标记;
c.然后判断当前结点是否满足二叉搜索树的性质，用retcur标记:
如果当前结点的val大于prev，说明满足条件，retcur改为true;
如果当前结点的val小于等于prev，说明不满足条件，retcur改为false;d.最后递归判断右子树是否是二文搜索树，用retright标记;
3.只有当retleft、retcur和retright都是true的时候，才返回true。

代码实现:

/**
 * 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 pre = Long.MIN_VALUE;
    public boolean isValidBST(TreeNode root) {
      // 如果为空肯定满足
      if(root == null){
        return true;
      }
      //二叉搜索树中序遍历是有序的
      boolean left = isValidBST(root.left);
      if(left==false){
        return false;
      }
      if(root.val<=pre){
         return false;
      }
      pre = root.val;
      boolean right = isValidBST(root.right);
      return right&&left;
    }
}

5. 二叉搜索树种的第 K 小的元素

题目链接: 二叉搜索树中第K小的元素

算法原理:（中序遍历+计数器剪枝）

我们可以根据中序遍历的过程,只需扫描前k个结点即可。
因此，我们可以创建一个全局的计数器count，将其初始化为k，每遍历一个节点就将count一。直到某次递归的时候，count的值等于1，说明此时的结点就是我们要找的结果。
算法流程:
1.定义一个全局的变量count，在主函数中初始化为k的值(不用全局也可以，当成参数传入递归过程中);

递归函数的设计: int dfs(TreeNode* root):·返回值为第k个结点;
递归函数流程（中序遍历)∶
1．递归出口:空节点直接返回-1，说明没有找到;

2.去左子树上查找结果,记为retleft:
a.如果retleft ==-1，说明没找到,继续执行下面逻辑;
b.如果retleft !=-1，说明找到了，直接返回结果，无需执行下面代码（剪枝);

3.如果左子树没找到，判断当前结点是否符合:
a.如果符合,直接返回结果
4．如果当前结点不符合，去右子树上寻找结果。

代码实现:

/**
 * 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 {
    // 中序遍历 + 计数器(二叉搜索树)
    int count=0;
    //要返回的值
    int ret=0;
    public int kthSmallest(TreeNode root, int k) {
      count = k;
      dfs(root);
      return ret;
    }

    public void dfs(TreeNode root){
        if(root == null || count == 0){
            return;
        }
        dfs(root.left);
        //剪枝
        if(count==0)return;
           count--;
          if(count==0){
            ret = root.val;
            return;
          }
        dfs(root.right);
          if(count==0)return;
    }
}

6. 二叉树的所有路径

题目链接: 257. 二叉树的所有路径

算法原理:

使用深度优先遍历(DFS)求解。
路径以字符串形式存储，从根节点开始遍历，每次遍历时将当前节点的值加入到路径中，如果该节点为叶子节点，将路径存储到结果中。否则，将"->"加入到路径中并递归遍历该节点的左右子树。定义一个结果数组，进行递归。递归具体实现方法如下:
1．如果当前节点不为空，就将当前节点的值加入路径path中，否则直接返回;
2.判断当前节点是否为叶子节点，如果是，则将当前路径加入到所有路径的存储数组paths中;

3．否则，将当前节点值加上">"作为路径的分隔符，继续递归遍历当前节点的左右子节点。4．返回结果数组。
·特别地，我们可以只使用一个字符串存储每个状态的字符串，在递归回溯的过程中，需要将路径中的当前节点移除,以回到上一个节点。
具体实现方法如下:
1.定义一个结果数组和一个路径数组。
2.从根节点开始递归，递归函数的参数为当前节点、结果数组和路径数组。
a．如果当前节点为空，返回。
b.将当前节点的值加入到路径数组中。
c.如果当前节点为叶子节点，将路径数组中的所有元素拼接成字符串，并将该字符串存储结果数组中。
d．递归遍历当前节点的左子树。

e．递归遍历当前节点的右子树。
f．回溯，将路径数组中的最后一个元素移除，以返回到上一个节点。3．返回结果数组。

代码实现:

import java.util.ArrayList;
import java.util.List;

/**
 * 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) {
        dfs(root,new StringBuffer());
        return ret;
    }
    public void dfs(TreeNode root,StringBuffer _path){
        //这里要创建新的 path(1->2) ,这样dfs左边的path(1->2->3),就不会影响原来的 path(1->2) ,再去递归右边的还是(1->2)
        StringBuffer path = new StringBuffer(_path);
        //出口
        if(root == null){
            return;
        }
        //加入当前值
        path.append(Integer.toString(root.val));
        //如果是叶子节点
        if(root.left == null && root.right == null){
            ret.add(path.toString());
            return;
        }else{
            path.append("->");
        }
        //递归左右子树
        dfs(root.left,path);
        dfs(root.right,path);
    }
}

总结

以上就是关于二叉树的深搜算法的几道例题啦，如果有问题，可以再评论区讨论，看到必回！

希望可以帮助到大伙，动动小手点个赞我会开心很久，感谢阅览。

Y_3_7

关注

31
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
【DFS算法】二叉树中的深搜

1.计算布尔二叉树的值(medium)2.求根节点到叶节点数字之和(medium)3.二叉树剪枝(medium)4.验证二叉搜索树(medium)5.二叉搜索树种的第K小的元素6.二叉树的所有路径
复制链接

扫一扫

专栏目录