[Leetcode] Binary tree--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.

 

Solution:

1. use iterative way;  bfs 

 1   if root is None:
 2             return False
 3         d = deque()
 4         
 5         d.append((root, root.val))
 6 
 7         while(len(d)):
 8             nodeInfo = d.popleft()
 9             node = nodeInfo[0]
10             s = nodeInfo[1]
11             if (not node.left) and (not node.right):
12                 if s == sum:
13                     return True
14             if node.left:
15                 d.append((node.left, s + node.left.val))
16             if node.right:
17                 d.append((node.right, s + node.right.val))
18         return False

 

 2. use recursive way

 1         return self.haspathSumHelper(root, 0, sum)
 2         
 3     def haspathSumHelper(self, node, current, sum):
 4         
 5         if node is None:
 6             return False
 7         current += node.val
 8         if (not node.left ) and (not node.right):
 9             if current == sum:
10                 return True
11             else:
12                 return False
13             
14         
15         return self.haspathSumHelper(node.left, current, sum) or self.haspathSumHelper(node.right, current, sum)