2021-03-14

二叉树中根节点到叶子节点的路径

112. 路径总和

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

说明: 叶子节点是指没有子节点的节点。

示例:  给定如下二叉树，以及目标和 sum = 22，

返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。

 

---

class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if (root == null) {
            return false;
        }
//先序遍历，碰到叶子节点判断是否找到
        if (root.left == null && root.right == null) {
            return sum - root.val == 0;
        }
//最后的结果是左子树找到或者右子树找到，或者都没有找到
        return hasPathSum(root.left, sum - root.val)
                || hasPathSum(root.right, sum - root.val);
    }
}

257.二叉树的所有路径

给定一个二叉树，返回所有从根节点到叶子节点的路径。

说明: 叶子节点是指没有子节点的节点。

class Solution {
    List<String> res = new ArrayList<>();
    public List<String> binaryTreePaths(TreeNode root) {
        String path = "";
        dfs(root, path);

        return res;
    }

    public void dfs(TreeNode root, String path){
        if(root == null){
            return;
        }
        
        if(root.left == null && root.right == null){
            path = path+root.val;
            res.add(path);
        }
        path = path+root.val+"->";
        dfs(root.left, path);
        dfs(root.right, path);
    }
}

 

113. 路径总和II

给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。

说明: 叶子节点是指没有子节点的节点。

示例: 给定如下二叉树，以及目标和 sum = 22，

class Solution {
    List<List<Integer>> allPath = new ArrayList<>();
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        List<Integer> list = new ArrayList<>(); 
        dfs(root, targetSum, list);
        return allPath;

    }

    public void dfs(TreeNode root, int targetSum, List<Integer> path){
        //如果节点为空直接返回
        if(root == null){
            return;
        }
        path.add(root.val);
        if(root.left == null && root.right == null){
            int sum = pathSum(path);
            if(sum == targetSum){
                allPath.add(new ArrayList<>(path));
            }
        }

        dfs(root.left, targetSum, path);
        dfs(root.right, targetSum, path);
        //因为list是引用传递，改变之后值会发生变化，所以我们把这个值使用完之后还要把它给移除，这就是回溯
        path.remove(path.size()-1);

    }

    public int pathSum(List<Integer> path){
        int sum = 0;
        for(int a:path){
            sum+=a;
        }
        return sum;
    }
}

 

---

 

 

129.求根节点到叶节点数字之和

给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。
每条从根节点到叶节点的路径都代表一个数字：

例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。
计算从根节点到叶节点生成的 所有数字之和 。

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

class Solution {
    int sum = 0;
    public int sumNumbers(TreeNode root) {
        if(root == null){
            return 0;
        }
        dfs(root,0);
        return sum;
    }

    public void dfs(TreeNode root, int pathSum){
        if(root == null){
            return;
        }
        pathSum = pathSum * 10 + root.val;
        //遍历到叶子节点的时候计算数字之和
        if(root.left == null && root.right == null){
            sum += pathSum;
            //return;
        }
        dfs(root.left, pathSum);
        dfs(root.right, pathSum);
        //递归的时候系统栈会帮我们记录状态，因此这里不需要我们手动回溯也可以
        //pathSum = pathSum/10;
    }

}