[Leetcode 11] 112 Path Sum

Problem:

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.

 

Analysis:

Basically, it's a depth first search problem. We need to enumerate all the possible path sums to check whether there's one path equals to the given sum. We use recursion to solve this problem. If one node's left and right children are all null, we know we reach the end of a path, then we need to test whether this path sum equals to the given value. If equals, we return true immediately. If not, we return false immediately. Then if there's at least one child of the current node is not null, we are in the middle of a path. If only one child, we just consider the sum of this child's path. If two children, we take the "or" result of the two path sums. By using this recursion, we can judge the whether there's one legal path in the given tree.

One thing need to notice is that, the judge sum condition can't be delayed to the node is null, saying "if (node == null) then ...". This judgement is wrong because there is the case that a node has only one child, then the other is null. And given this null, the programm thinks it reaches a path's end while actually this is not the legal path. A simple case is given below:

  1

2

and the sum is 1. The actual result is false while the above method will return true;

 

Code:

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        // Start typing your Java solution below
        // DO NOT write main() function
        if (root == null) 
            return false;
        else
            return pathSum(root, 0, sum);
    }
    
    private boolean pathSum(TreeNode node, int pathsum, int sum) {
        int s = pathsum + node.val;
        
        if (node.left == null && node.right == null) {
            if (s == sum)
                return true;
            else
                return false; //do nothing
        } else
        if (node.left != null && node.right == null) {
            return pathSum(node.left, s, sum);
        } else if (node.left == null && node.right != null) {
            return (pathSum(node.right, s, sum));
        } else { //both not null
            return (pathSum(node.right, s, sum) || pathSum(node.left, s, sum));
        } 
    }
    
}

 

Attention:

Learn how to DFS over a tree!