Path Sum 二叉树中和为某一值的路径

Leetcode 112/113/437. Path Sum

参考：剑指offer 26：二叉树中和为某一值的路径

 

112：

Given a binary tree and a sum, determineif the tree has a root-to-leaf path such that adding up all the values alongthe path equals the given sum.

For example:
Given the below binary tree and sum = 22,

              5

             / \

            4  8

           /  / \

          11 13  4

         / \      \

        7   2      1

return true, as there exist aroot-to-leaf path 5->4->11->2 which sumis 22.

 

这道题是为了判断二叉树中有没有从顶到叶子节点的一个路径，使得路径上的值的和为目标值。

分析：很简单，不需要记录路径，直接使用递归

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public boolean hasPathSum(TreeNode root, int sum){
        if(root==null){
            return false;
        }
        if(root.right==null&&root.left==null){
            return (sum==root.val);
        }
        boolean b1=(root.left!=null)?(hasPathSum(root.left,sum-root.val)):false;
        boolean b2=(root.right!=null)?(hasPathSum(root.right,sum-root.val)):false;
        return b1||b2;
    }
}

113：

Given a binary tree and a sum, find allroot-to-leaf paths where each path's sum equals the given sum.

For example:
Given the below binary tree and sum = 22,

              5

             / \

            4  8

           /  / \

          11 13  4

         / \    / \

        7   2  5   1

return

[

   [5,4,11,2],

   [5,8,4,5]

]

这个题比上个题稍微难了一些，需要给出路径了。

分析：我们可以使用一个栈来暂存路径。同样使用递归（前序遍历）来遍历二叉树。当用前序遍历的方式访问到某一节点时，我们把该节点添加到路径上。如果该节点为叶子节点并且路径中的值的和正好等于目标值，则当前路径符合要求，存到我们的res中。 如果当前节点不是叶子节点，则访问其子节点。子节点访问结束后，需要在暂存栈弹出当前节点。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        ArrayList<List<Integer>> res=new ArrayList<List<Integer>>();
        Stack<Integer> cache=new Stack<Integer>();
        if(root==null){
            return res;
        }
        respathSum(root,sum,cache,res);
        return res;
    }
    public void respathSum(TreeNode root,int sum,Stack<Integer> cache,ArrayList<List<Integer>> res){
        cache.push(root.val);
        if(root.left==null&&root.right==null&&root.val==sum){
            Stack <Integer> s=new Stack<Integer>();
            s.addAll(cache);
            res.add(s);
        }
        if(root.left!=null){
            respathSum(root.left,sum-root.val,cache,res);
        }
        if(root.right!=null){
            respathSum(root.right,sum-root.val,cache,res);
        }
        cache.pop();
    }
}

 

437

You are given a binary tree in which each node contains an integervalue.

Find the number of paths that sum to a given value.

The path does not need to start or end at the root or a leaf,but it must go downwards (traveling only from parent nodes to child nodes).

The tree has no more than 1,000 nodes and the values are in therange -1,000,000 to 1,000,000.

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

这个题又比上个题要难一点，路径可能不从根节点开始，也可能不在叶子节点结束。但是不需要所有路径，只需要给出可能的路径值就行了。这里同样使用递归（前序遍历），同样需要注意在处理完左右子节点之后，需要一个回到父节点状态的操作。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int pathSum(TreeNode root, int sum) {
        if(root==null){
            return 0;
        }
        ArrayList <Integer> a=new ArrayList<Integer>();
        Para p=new Para();
        p.cache=0;
        p.a=a;
        p.sum=sum;
        respathSum(root,p);
        return p.cache;
    }
    public void respathSum(TreeNode root,Para p){
        for(int i=0;i<(p.a).size();i++){
            (p.a).set(i,(p.a).get(i)+root.val);
        }
        (p.a).add(root.val);
        for(int i:(p.a)){
            if(i==p.sum){
                p.cache++;
            }
        }
        if(root.left!=null){
            respathSum(root.left,p);
        }
        if(root.right!=null){
            respathSum(root.right,p);
        }
        for(int i=0;i<(p.a).size();i++){
            (p.a).set(i,(p.a).get(i)-root.val);
        }
        (p.a).remove((p.a).size()-1);
    }
}
class Para{
    ArrayList<Integer> a;
    int cache;
    int sum;
}