LeetCode - Path Sum

Path Sum

2014.1.8 04:59

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.

Solution:

　　This problem has no constraint on the value of the tree nodes, neither being sorted nor limited to a certain range. Thus we can only perform a thorough recursive search. Note that it's root-to-leaf, so don't stop halfway on non-leaf nodes.

　　Time and space complexities are both O(n), where n is the number of nodes in the tree. Space complexity comes from local parameters passed in function calls.

Accepted code:

 1 /**

 2  * Definition for binary tree

 3  * struct TreeNode {

 4  *     int val;

 5  *     TreeNode *left;

 6  *     TreeNode *right;

 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}

 8  * };

 9  */

10 class Solution {

11 public:

12     bool hasPathSum(TreeNode *root, int sum) {

13         // Note: The Solution object is instantiated only once and is reused by each test case.

14         if(root == nullptr){

15             return false;

16         }

17 

18         if(root->left == nullptr){

19             if(root->right == nullptr){

20                 return root->val == sum;

21             }else{

22                 return hasPathSum(root->right, sum - root->val);

23             }

24         }else{

25             if(root->right == nullptr){

26                 return hasPathSum(root->left, sum - root->val);

27             }else{

28                 return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);

29             }

30         }

31     }

32 };