[LeetCode]112. Path Sum

Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the 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 a root-to-leaf path 5->4->11->2 which sum is 22.

和【257】那道差不多的思路，递归遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    
    List<Integer> list = new ArrayList();

    public boolean hasPathSum(TreeNode root, int sum) {
        if(root==null) return false;
        
        int current=root.val;
        singlePathSum(root, current);
        
        for(int num: list){
            if(num==sum)
                return true;
        }
        
        return false;
    }
    
    public void singlePathSum(TreeNode root,  int current){
        if(root.left==null && root.right==null)
        {
            list.add(current);
        }
        
        if(root.left!=null) singlePathSum(root.left, current+root.left.val);
        if(root.right!=null) singlePathSum(root.right, current+root.right.val);
    }
}

我这里用了个list来存放每一次遍历的结果，其实不用这样的，直接在递归到末节点的时候判断数值是否相等。

public class Solution {
    private boolean stop = false; // 判断是否已经找到答案

    public boolean hasPathSum(TreeNode root, int sum) {
        calculate(root, 0, sum);
        return stop;
    }

    /**
     * 计算根到叶子结点的和
     * @param node 当前处理的节点
     * @param cur 从根节点到当前结点之前的所有节点和
     * @param sum 要求的和
     */
    private void calculate(TreeNode node, int cur, int sum) {
        if (!stop && node != null) { // 还没有找到答案，并且要处理的节点不为空

            // 如果是叶节点，就检查从根到当前叶节点的和是否为sum，如果是就说明已经找到，改变stop
            if (node.left == null && node.right == null && (node.val + cur == sum) ) {
                stop = true;
            }

            // 如果是非叶节点，继续处理
            if (node.left != null) {
                calculate(node.left, cur + node.val, sum);
            }

            if (node.right != null) {
                calculate(node.right, cur + node.val, sum);
            }
        }
    }
}