LeetCode刷题笔录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.

想法是用DFS。两个Stack，一个存储node,一个存储从root到这个node（包括这个node）的path sum。每次从nodeStack里pop一个node出来，也从sumStack里pop一个int出来，两者一一对应。然后先判断这个node是不是leaf。是的话再判断sum是不是等于给定值。

    public boolean hasPathSum(TreeNode root, int sum) {
        if(root == null)
            return false;
        Stack<TreeNode> nodeStack = new Stack<TreeNode>();
        Stack<Integer> sumStack = new Stack<Integer>();
        nodeStack.push(root);
        sumStack.push(root.val);
        while(!nodeStack.isEmpty()){
            TreeNode node = nodeStack.pop();
            int currSum = sumStack.pop();
            if(node.left == null && node.right == null && currSum == sum)
                return true;
            else{
                if(node.left != null){
                    nodeStack.push(node.left);
                    sumStack.push(currSum + node.left.val);
                }
                if(node.right != null){
                    nodeStack.push(node.right);
                    sumStack.push(currSum + node.right.val);
                }
                
            }
        }
        return false;
    }
}

既然是DFS，那么也可以用递归，在递归函数里加一个当前的currSum即可。

public class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        return hasPathSum(root, sum, 0);
    }
    
    public boolean hasPathSum(TreeNode node, int sum, int currSum){
        if(node == null)
            return false;
        currSum += node.val;
        if(node.left == null && node.right == null){
            if(sum == currSum)
                return true;
            else
                return false;
        }
        return hasPathSum(node.left, sum, currSum) || hasPathSum(node.right, sum, currSum);
    }
}