leetcode112-路径总和

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.1 递归方法

  假定从根节点到当前节点的值之和为 val，我们可以将这个大问题转化为一个小问题：是否存在从当前节点的子节点到叶子的路径，满足其路径和为 sum - val。

  不难发现这满足递归的性质，若当前节点就是叶子节点，那么我们直接判断 sum 是否等于 val 即可（因为路径和已经确定，就是当前节点的值，我们只需要判断该路径和是否满足条件）。若当前节点不是叶子节点，我们只需要递归地询问它的子节点是否能满足条件即可。

 public boolean hasPathSum(TreeNode root,int targetSum){
    
    
        if(root==null){
    
    
            return false;
        }
        if(root.left==null&&root.right==null){
    
    
            return targetSum==root.val;
        }
        return hasPathSum(root.left,targetSum-root.val)||hasPathSum(root.right,targetSum-root.val);
    }

2.2 广度优先遍历

  首先我们可以想到使用广度优先搜索的方式，记录从根节点到当前节点的路径和，以防止重复计算。

  这样我们使用两个队列，分别存储将要遍历的节点，以及根节点到这些节点的路径和即可。

//方法二：广度优先搜索
    //使用广度优先遍历搜索的方式，记录从根节点到当前节点的路径和
    public boolean hasPathSum1(TreeNode root,int sum){
    
    
        if(root==null){
    
    
            return false;
        }
        //使用两个队列分别存储将要遍历的节点，以及根节点到这些节点得路径和
        LinkedList<TreeNode> queNode = new LinkedList<>();
        LinkedList<Integer> queVal = new LinkedList<>();
        //根节点和值入队
        queNode.add(root);
        queVal.add(root.val);
        while(!queNode.isEmpty()){
    
    
            //节点和值出队
            TreeNode now = queNode.remove();
            int temp=queVal.remove();
            if(now.left==null&&now.right==null){
    
        //判断叶子节点的路径和
                if(temp==sum){
    
    
                    return true;
                }
                continue;
            }
            if(now.left!=null){
    
    //左节点入队
                queNode.add(now.left);
                queVal.add(now.left.val+temp);
            }
            if(now.right!=null){
    
    //右节点入队
                queNode.add(now.right);
                queVal.add(now.right.val+temp);
            }
        }
        return false;
    }

  测试下：

 public static void main(String[] args) {
    
    
        TreeNode t1 = new TreeNode(1);
        TreeNode t2 = new TreeNode(2);
        TreeNode t3 = new TreeNode(3);
        t1.left=t2;
        t1.right=t3;
        LeetCode112 code112 = new LeetCode112();
        System.out.println(code112.hasPathSum(t1, 3));
        System.out.println(code112.hasPathSum(t1, 5));
        System.out.println(code112.hasPathSum1(t1, 3));
        System.out.println(code112.hasPathSum1(t1, 4));
    }