[Leetcode 112, Easy] Path sum I

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:

The below solutions are recursive. Recursive methods are straightforward.

Of course, we can use non-recursive method to solve them.

1. Below progrem is a typical recursive solution to such problems. The function getPath returns when the recursive pointer reaches a leaf.

2. Notice a boundary case: a tree with only one node, root and its value is equal to the sum.

Solution:

C++:

Recursive solution: (12 ms)

    void CalculatePathSums(TreeNode* local_root, int sum, bool& hasPath)    {        if(local_root->left == NULL && local_root->right == NULL) {            if(sum == local_root->val)                hasPath = true;            return;        } else {            if(!hasPath && local_root->left != NULL)                CalculatePathSums(local_root->left, sum - local_root->val, hasPath);                            if(!hasPath &&  local_root->right != NULL)                CalculatePathSums(local_root->right, sum - local_root->val, hasPath);        }    }        bool hasPathSum(TreeNode *root, int sum) {        bool rv = false;        if(root != NULL)            CalculatePathSums(root, sum, rv);        return rv;    }

Non-recursive solution: (12 ms)

    bool hasPathSum(TreeNode *root, int sum)    {        if(root == NULL)            return false;                bool found = false;        stack<TreeNode *> node_stack;        TreeNode *p_cur = root;        TreeNode *visited = NULL;        int sum_backup = sum;        while(p_cur || !node_stack.empty()) {            if(p_cur) {                sum -= p_cur->val;                node_stack.push(p_cur);                if(p_cur->left == NULL && p_cur->right == NULL && sum == 0) {                    found = true;                    break;                }                p_cur = p_cur->left;            } else {                p_cur = node_stack.top();                if(p_cur->right == NULL || p_cur->right == visited) {                    sum += p_cur->val;                    node_stack.pop();                    visited = p_cur;                    p_cur = NULL;                } else                    p_cur = p_cur->right;            }        }                return found;    }