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> pathSum(TreeNode root, int sum) {
ArrayList> res=new ArrayList>();
Stack cache=new Stack();
if(root==null){
return res;
}
respathSum(root,sum,cache,res);
return res;
}
public void respathSum(TreeNode root,int sum,Stack cache,ArrayList> res){
cache.push(root.val);
if(root.left==null&&root.right==null&&root.val==sum){
Stack s=new Stack();
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 a=new ArrayList();
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 a;
int cache;
int sum;
}