【每日算法】112. 路径总和

「这是我参与2022首次更文挑战的第13天，活动详情查看：2022首次更文挑战」。

描述

给你二叉树的根节点 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

解释：由于树是空的，所以不存在根节点到叶子节点的路径。  

做题

这道题要我们计算从根节点开始一直到叶子节点，看看是否有一条路线上的节点的值加起来等于 targetSum。

深度优先/递归法

比较简单的做法就是深度优先了，遍历每一条从根节点到叶子节点的路线，targetSum 一路往下，减去节点的 val，看看到达叶子节点后是不是刚好等于叶子节点的 val。

public boolean hasPathSum(TreeNode root, int targetSum) {
        if(root == null){
            return false;
        }
        if(root.left == null && root.right == null){
            //当前为叶子节点
            return root.val == targetSum;
        }
        int next = targetSum - root.val;
        return hasPathSum(root.left,next) || hasPathSum(root.right,next);
    }

广度优先/迭代法

广度优先的做法就是从根节点开始一层一层地往下加节点的 val，如果当前的节点大于了 targetSum，就不继续了。如果小于就继续，一直到叶子节点。

public boolean hasPathSum(TreeNode root, int targetSum) {
        //存放每路的节点和
        Queue<Integer> sumQueue = new LinkedList();
        //存放要遍历的节点
        Queue<TreeNode> nodeQueue = new LinkedList();
        sumQueue.offer(0);
        nodeQueue.offer(root);
        while(!sumQueue.isEmpty()){
            int sum = sumQueue.poll();
            TreeNode node = nodeQueue.poll();
            if(node == null){
                continue;
            }
            sum += node.val;
            if(node.left==null && node.right==null && sum == targetSum){
                return true;
            }
            if(node.left !=null){
                sumQueue.offer(sum);
                nodeQueue.offer(node.left);
            }
            if(node.right !=null){
                sumQueue.offer(sum);
                nodeQueue.offer(node.right);
            }
        }
        return false;
    }

感觉迭代法也没有比递归法好多少。