This problem has a very easy recursive code as follows.
1 class Solution { 2 public: 3 bool hasPathSum(TreeNode* root, int sum) { 4 if (!root) return false; 5 if (!(root -> left) && !(root -> right)) 6 return sum == root -> val; 7 return hasPathSum(root -> left, sum - root -> val) || 8 hasPathSum(root -> right, sum - root -> val); 9 } 10 };
If you insist on an iterative solution, this link has a clean iterative solution in Python. I rewrite the code in C++ as follows. In fact, it uses pair<TreeNode*, int> to recor the information, which greatly simplifies the code.
1 class Solution { 2 public: 3 bool hasPathSum(TreeNode* root, int sum) { 4 if (!root) return false; 5 stack<pair<TreeNode*, int> > pairs; 6 pairs.push(make_pair(root, sum)); 7 while (!pairs.empty()) { 8 pair<TreeNode*, int> pr = pairs.top(); 9 pairs.pop(); 10 TreeNode* node = pr.first; 11 int remain = pr.second; 12 if (!(node -> left) && !(node -> right) && remain == node -> val) 13 return true; 14 if (node -> left) 15 pairs.push(make_pair(node -> left, remain - node -> val)); 16 if (node -> right) 17 pairs.push(make_pair(node -> right, remain - node -> val)); 18 } 19 return false; 20 } 21 };
This link gives a longer iterative solution using postorder traversal.
1 class Solution { 2 public: 3 bool hasPathSum(TreeNode* root, int sum) { 4 TreeNode* pre = NULL; 5 TreeNode* cur = root; 6 stack<TreeNode*> nodes; 7 int s = 0; 8 while (cur || !nodes.empty()) { 9 while (cur) { 10 nodes.push(cur); 11 s += cur -> val; 12 cur = cur -> left; 13 } 14 cur = nodes.top(); 15 if (!(cur -> left) && !(cur -> right) && s == sum) 16 return true; 17 if (cur -> right && pre != cur -> right) 18 cur = cur -> right; 19 else { 20 pre = cur; 21 nodes.pop(); 22 s -= cur -> val; 23 cur = NULL; 24 } 25 } 26 return false; 27 } 28 };