【LeetCode】第112题——路径总和（难度：简单）

题目描述

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

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

1. 示例:
   给定如下二叉树，以及目标和 sum = 22，
   
   返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/path-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

思路一：本人认为此题从BFS的解法开始思考比较简单，如果当前节点的左节点不为空，则把当前节点的值加到左节点的值上，右节点同理。如果当前节点的值等于题目的给定值，且无叶子节点，即可认为满足题意，返回true。

思路二：递归。代码相对于思路一来说非常简练，但是比较难以想到。假定从根节点到当前节点的值之和为val，我们可以将这个大问题转化为一个小问题：是否存在从当前节点的子节点到叶子的路径，满足其路径和为sum - val。（相当巧妙）

如果一下子用递归想不到，就考虑试试用用BFS循环解法。

代码详解

思路一：BFS（本人写的看起来很冗长，但思路很清晰）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        // 特殊情况1：空树，直接返回false
        if (root == null) {
            return false;
        // 特殊情况2：只有根节点，且根节点的值等于给定值（不等于的情况会被后续的代码判断出）
        } else if (root.val == sum && root.left == null && root.right == null) {
            return true;
        }
        Queue<TreeNode> queue = new LinkedList<>(); // 利用队列先入先出的特点，BFS惯用思路
        TreeNode p = root.left;
        TreeNode q = root.right;
        // 如果叶子节点存在，则把根节点的值加到叶子节点的值上
        if (p != null) {
            p.val = p.val + root.val;
        }
        if (q != null) {
            q.val = q.val + root.val;
        }
        // 入队
        queue.offer(p);
        queue.offer(q);
        while(!queue.isEmpty()){
            int size = queue.size();
            while(size > 0) {
            	// 出队
                p = queue.poll();
                q = queue.poll();
                if (p != null) {
                    queue.offer(p.left);
                    queue.offer(p.right);
                    // 三个条件同时满足才能返回true
                    if (p.val == sum && p.left == null && p.right == null) {
                        return true;
                    }
                    // 否则就把当前节点的val加到叶子节点的value里
                    if (p.left != null) {
                        p.left.val = p.left.val + p.val;
                    }
                    if (p.right != null) {
                        p.right.val = p.right.val + p.val;
                    }
                }
                // 同左叶子节点
                if (q != null) {
                    queue.offer(q.left);
                    queue.offer(q.right);
                    if (q.val == sum && q.left == null && q.right == null) {
                        return true;
                    }
                    if (q.left != null) {
                        q.left.val = q.left.val + q.val;
                    }
                    if (q.right != null) {
                        q.right.val = q.right.val + q.val;
                    }
                }
                size = size - 2;
            }
        }
        // 遍历完了都没有满足条件的路径，返回false
        return false;
    }
}

思路二：递归（此处引用官方题解，我太菜了）

class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
    	// 空树，返回false
        if (root == null) {
            return false;
        }
        // 遍历到叶子节点了，判断当前路径之和是否等于给定值
        if (root.left == null && root.right == null) {
            return sum == root.val;
        }
        // sum - root.val是神来之笔，佩服
        return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
    }
}

注意点

1. 本人的BFS思路采用逐层以加的方式更新val，判断和是否等于给定值。
2. 递归思路是采用逐层以减的方式更新val，判断最后的值是否等于叶子节点的值。