常见算法 - 二叉树：(递归) 求根节点到叶子节点的所有路径、求二叉树中和为定值的任意路径

 求根节点到叶子节点的所有路径Leetcode(257)：

递归的简单应用，注意返回的是所有路径，所以当前节点要于子节点的所有路径都连接一次。

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        
        List<String> res = new ArrayList<String>();
        if(root == null){
            return res;
        }
        
        if(root.left == null && root.right == null){
            res.add(""+root.val);
            return res;
        }
        List<String> leftS = binaryTreePaths(root.left);
        for(int i = 0; i< leftS.size(); i++){
            res.add(""+root.val+"->"+leftS.get(i));
        }
        List<String> rightS = binaryTreePaths(root.right);
        for(int i = 0; i< rightS.size(); i++){
            res.add(""+root.val+"->"+rightS.get(i));
        }
        return res;
    }
}

求二叉树中和为定值的任意路径（leetcode437）

Example:

root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8

      10
     /  \
    5   -3
   / \    \
  3   2   11
 / \   \
3  -2   1

Return 3. The paths that sum to 8 are:

1.  5 -> 3
2.  5 -> 2 -> 1
3. -3 -> 11

这里与之前的根节点到叶子节点的路径和不同。这里是任意节点，所以需要考虑当前不加入到路径中的情况，也就是对于每一个节点，它只有加入路径和不加入路径两种情况。其他就是递归了。

class Solution {
    public int pathSum(TreeNode root, int sum) {
        
        if(root == null){
            return 0;
        }
        
        int res = 0;
        //当前节点加入路径的情况下满足条件的路径总数
        res += findPath(root,sum);
        //当前节点不加入路径,递归调用,即从其左节点开始的满足条件的路径和
        res += pathSum(root.left,sum);
        //当前节点不加入路径,递归调用,即从其又节点开始的满足条件的路径和
        res += pathSum(root.right,sum);
        return res;
    }
    
     //实现当前节点出发经过节点都加入到路径中满足条件的路径总和
    public static int findPath(TreeNode root,int sum){
        
        int res = 0;
        if(root == null){
            return 0;
        }
        if(root.val == sum){
            res += 1;
        }
        res += findPath(root.left,sum-root.val);
        res += findPath(root.right,sum-root.val);
        return res;
    }
}