（非递归的方法待研究）112. Path Sum

112. 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 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.

方法一、前序遍历

bool hasPathSum(TreeNode* root, int sum,vector<int> &que,int currentSum) //前序遍历保证的才是先从根节点开始
    {
        currentSum += root->val;
        que.push_back(root->val);
        if(currentSum == sum && root->left == NULL && root->right == NULL)
            return true;
        
        bool left = false;
        if(root->left != NULL)
            left = hasPathSum(root->left,sum,que,currentSum);
        
        bool right = false;
        if(root->right != NULL)
            right = hasPathSum(root->right,sum,que,currentSum);
            
        que.pop_back();
        return left||right;
    }
    
    bool hasPathSum(TreeNode* root, int sum) {
        if(NULL == root)
            return false;
        
        vector<int> que;
        int currentSum = 0;
        return hasPathSum(root,sum,que,currentSum);
    }

方法二、递归方法

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

方法三、非递归的前序遍历

bool hasPathSum(TreeNode *root, int sum) {
        stack<TreeNode *> s;
        TreeNode *pre = NULL, *cur = root;
        int SUM = 0;
        while (cur || !s.empty()) {
            while (cur) {
                s.push(cur);
                SUM += cur->val;
                cur = cur->left;
            }
            cur = s.top();
            if (cur->left == NULL && cur->right == NULL && SUM == sum) {
                return true;
            }
            if (cur->right && pre != cur->right) {
                cur = cur->right;
            } else {
                pre = cur;
                s.pop();
                SUM -= cur->val;
                cur = NULL;
            }
        }
        return false;
    }