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 andsum = 22,

              5             / \            4   8           /   / \          11  13  4         /  \      \        7    2      1

Return true, as there exist a root-to-leaf path5->4->11->2Which sum is 22.

Solution:

Because we need to find the path from the root to the leaf node, we can know by traversing a tree.

There are four methods: sequential traversal, central traversal, post-sequential traversal, and hierarchical traversal. You can select either of them.

Solution code (non-recursive ):

/** * Definition for binary tree * struct TreeNode { *     int val; *     TreeNode *left; *     TreeNode *right; *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public:    bool hasPathSum(TreeNode *root, int sum) {        if(!root)            return false;        queue
 
   > que;        que.push(make_pair(root,root->val));        while(!que.empty())        {            pair
  
    p = que.front();            que.pop();            if(p.first->left == NULL && p.first->right == NULL && p.second == sum)                return true;            if(p.first->left)                que.push(make_pair(p.first->left,p.second + p.first->left->val));            if(p.first->right)                que.push(make_pair(p.first->right,p.second + p.first->right->val));        }        return false;    }};
  
 

Solution code (recursive ):

/** * Definition for binary tree * struct TreeNode { *     int val; *     TreeNode *left; *     TreeNode *right; *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public:    bool dfs(TreeNode *rt,long long sum)    {        if (rt->left == rt->right && !rt->left)            return sum == rt->val ;        if (rt->left && rt->right)            return dfs(rt->left,sum - rt->val) | dfs(rt->right,sum - rt->val);        return dfs(rt->left ? rt->left : rt->right, sum - rt->val);    }    bool hasPathSum(TreeNode *root, int sum)     {        return root ? dfs(root,sum) : false ;       }};