Path Sum (leetcode)

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.

https://oj.leetcode.com/problems/path-sum/

1> 非递归算法

  非递归后序遍历二叉树的方式访问二叉树，使用std::stack, 将访问到的节点入栈，当访问到叶节点时，判断从根节点到叶节点的总和stack_sum是否和指定的sum相等，如相等返回true，否则继续遍历二叉树，当遍历完整个二叉树后，还未遇到相同值后，返回false。

code：

/**
 * 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) {
        // postorder traversal iteratively using stack
		if (!root) {
			return false;
		}

		TreeNode *curr = root;
		TreeNode *prev_visited = NULL;
		std::stack<TreeNode *> mystack;
		int stack_sum = 0;
		bool is_left_child_visited = false;

		do {
			while (curr && !is_left_child_visited) {
				mystack.push(curr);
				stack_sum += curr->val;
				curr = curr->left;
			}
			curr = mystack.top();
			if (curr->right && curr->right != prev_visited) {
				//the right child is not visted
				curr = curr->right;
				is_left_child_visited = false;
			} else {
				if (!curr->left && !curr->right) {
					// it's leaf node, get the path sum from root to leaf 
					if (stack_sum == sum) {
						return true;
					}
				}
				is_left_child_visited = true;
				prev_visited = curr;
				stack_sum -= curr->val;
				mystack.pop();
			}
		} while (!mystack.empty());

		return false;
    }
};

2> 递归遍历算法

/**
 * 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;
		}
		if (!root->left && !root->right) {
			//leaf node
			return (root->val == sum);
		}

		return (hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val));
    }
};