path sum i

Problem Statement: 

Path sum i

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 one(traverse version): 

This is the traverse version.

For each node:

• Check if it is NULL, yes, return false
• If it is not NULL
• Update the sum, sum = sum - node->val

if current node is leaf node( node->left == NULL && node->right == NULL) and the new sum is equal to 0, we find the answer, return true.

Not leaf node, node left child is not empty and there is a path in left child or right child is not empty and there is a path in right child, return true.

Otherwise, return false.

 class Solution {
 public:
     bool hasPathSum(TreeNode* root, int sum) {
         if(root == NULL){
             return false;
         }
         sum -= root->val;
         if(sum ==  && root->left == NULL && root->right == NULL){
             return true;
         }
         if((root->left && hasPathSum(root->left, sum)) || (root->right && hasPathSum(root->right, sum))){
             return true;
         }
         return false;
     }
 };

Solution two(divide && conquer):

Divide the question to left and right, return true if there is one true between left and right.

otherwise, return false

 class Solution {
 public:
     bool hasPathSum(TreeNode* root, int sum) {
         if(root == NULL){
             return false;
         }

         sum -= root->val;
         if(root->left == NULL && root->right == NULL && sum == ){
             return true;
         }

         // divide
         bool leftHasPathSum = hasPathSum(root->left, sum);
         bool rightHasPathSum = hasPathSum(root->right, sum);

         // conquer
         if(leftHasPathSum || rightHasPathSum){
             return true;
         }
         return false;
     }
 };

Solution three(while loop and preorder to solve the problem):

Since we need find a path from root to leaf, the sum is equal to a given value. We traverse the tree from root by preorder: root->left->right.

Current node is not empty:

• if it is a leaf and sum is already equal to 0, we find a path, return true.
• else go to the left child of current node.

Current node is empty:

• Pop the top element from stack and pop the sum value from value stack, this value corresponding to the sum from root to current node.

Until the stack is empty, we return false.

 class Solution {
 public:
     bool hasPathSum(TreeNode* root, int sum) {
         if(root == NULL){
             return false;
         }
         stack<TreeNode*> node_stack;
         stack<int> val_stack;
         node_stack.push(root);
         val_stack.push(root->val);
         TreeNode* cur_node;
         int cur_val = ; 

         while(!node_stack.empty()){
             if(root){
                 cur_val += root->val;
                 node_stack.push(root);
                 val_stack.push(cur_val);
                 if(root->left == NULL && root->right == NULL && cur_val == sum){
                     return true;
                 } else {
                     root = root->left;
                 }
             } else {
                 root = node_stack.top();
                 node_stack.pop();
                 root = root->right;
                 cur_val = val_stack.top();
                 val_stack.pop();
             }
         }
         return false;
     }
 };

NOTES:

The important for non-traverse version is the value stack, we need keep a value stack. Each time, we need push the sum value to stack when we push a node to stack.

we can not keep a variable to store the sum for current node. That does not work.

I know how to solve this problem, however, spend much time for configure out that to keep a stack.