【数据结构与算法 | 灵神题单 | 自顶向下DFS篇】力扣1448, 112, 129

1. 力扣1448：统计二叉树中好节点的数量

1.1 题目：

给你一棵根为 root 的二叉树，请你返回二叉树中好节点的数目。

「好节点」X 定义为：从根到该节点 X 所经过的节点中，没有任何节点的值大于 X 的值。

示例 1：

输入：root = [3,1,4,3,null,1,5]
输出：4
解释：图中蓝色节点为好节点。
根节点 (3) 永远是个好节点。
节点 4 -> (3,4) 是路径中的最大值。
节点 5 -> (3,4,5) 是路径中的最大值。
节点 3 -> (3,1,3) 是路径中的最大值。

示例 2：

输入：root = [3,3,null,4,2]
输出：3
解释：节点 2 -> (3, 3, 2) 不是好节点，因为 "3" 比它大。

示例 3：

输入：root = [1]
输出：1
解释：根节点是好节点。

提示：

• 二叉树中节点数目范围是 [1, 10^5] 。
• 每个节点权值的范围是 [-10^4, 10^4] 。

1.2 思路：

全是一个套路，dfs遍历二叉树，用全局变量记录好节点的数量。

1.3 题解：

/**
 * 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 target;
    public int goodNodes(TreeNode root) {
        if(root == null){
            return 0;
        }
        recursion(root, root.val);
        return target;
    }
    private void recursion(TreeNode node, int x) {
        if(node == null){
            return;
        }
        // 用x变量来记录从根节点到该节点的路径上的最大值
        // 如果node的值比x还大，说明路径上的所有节点都比该节点的值要小
        // 也就是所谓的好节点
        // 如果该节点不是好节点，就继续向下找呗
        if(node.val >= x){
            target++;
            x = node.val;
        }
        recursion(node.left, x);
        recursion(node.right,x);
    }
}

2. 力扣112：路径总和

2.1 题目;

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。

示例 2：

输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：
(1 --> 2): 和为 3
(1 --> 3): 和为 4
不存在 sum = 5 的根节点到叶子节点的路径。

示例 3：

输入：root = [], targetSum = 0
输出：false
解释：由于树是空的，所以不存在根节点到叶子节点的路径。

提示：

• 树中节点的数目在范围 [0, 5000] 内
• -1000 <= Node.val <= 1000
• -1000 <= targetSum <= 1000

2.2 思路：

dfs遍历二叉树判断。跟上面题思路一样。

2.3 题解：

/**
 * 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 {
    // 全局变量判断是否有根节点到叶子节点的路径和相加等于targetsum
    boolean flag = false;
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if(root == null){
            return false;
        }
        recursion(null, root, targetSum);
        return flag;
    }
    private void recursion(TreeNode parent, TreeNode node, int targetSum) {
        if(node == null){
            return;
        }
        //parent == null,node为根节点的情况
        if(parent == null){

        } else {
            // 更新节点的值，此时节点的值就表示根节点到该节点的路径的和
            node.val += parent.val;
        }
        // 找到叶子节点判断它
        if(node.left == null && node.right == null){
            if(node.val == targetSum){
                flag = true;
            }
        }
        recursion(node, node.left, targetSum);
        recursion(node, node.right, targetSum);
    }
}

3. 力扣129：求根节点到叶节点数字之和

3.1 题目：

给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。

每条从根节点到叶节点的路径都代表一个数字：

• 例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。

计算从根节点到叶节点生成的 所有数字之和 。

叶节点 是指没有子节点的节点。

示例 1：

输入：root = [1,2,3]
输出：25
解释：
从根到叶子节点路径 1->2 代表数字 12
从根到叶子节点路径 1->3 代表数字 13
因此，数字总和 = 12 + 13 = 25

示例 2：

输入：root = [4,9,0,5,1]
输出：1026
解释：
从根到叶子节点路径 4->9->5 代表数字 495
从根到叶子节点路径 4->9->1 代表数字 491
从根到叶子节点路径 4->0 代表数字 40
因此，数字总和 = 495 + 491 + 40 = 1026

提示：

• 树中节点的数目在范围 [1, 1000] 内
• 0 <= Node.val <= 9
• 树的深度不超过 10

3.2 思路：

跟前面两题思路一样。

3.3 题解：

/**
 * 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 sum;
    public int sumNumbers(TreeNode root) {
        recursion(null, root);
        return sum;
    }
    private void recursion(TreeNode parent, TreeNode node) {
        if(node == null){
            return;
        }
        // node为根节点的情况，不需要考虑什么乱七八糟的东西
        if(parent == null){

        }else{
            // 如果node不是根节点，则更新节点的值
            node.val += 10*parent.val;
        }
        // 如果是叶子节点，就加入到全局变量sum中
        if(node.left == null && node.right == null){
            sum += node.val;
        }
        recursion(node, node.left);
        recursion(node, node.right);
    }
}