# coding=utf-8
"""Binary Tree Zigzag Level Order Traversal.
>>> solve = _solve
"""
from TreeNode import TreeNode
def _solve(root):
if not root:
return []
step, queue, ans = 1, [root], []
while queue:
ans.append([node.val for node in queue[::step]])
queue = [
kid for node in queue for kid in (node.left, node.right) if kid
]
step *= -1
return ans
assert _solve(TreeNode.de_serialize('[3,9,20,null,null,15,7]')) == [[3],
[20, 9],
[15, 7]]
if root.right:
_help(root.right, depth + 1, result)
return result[0]
return _help(root, 1, [0, 0])
# BFS with tricks
def _solve2(root):
queue = [root]
for node in queue:
queue += filter(None, (node.right, node.left))
return node.val
# BFS in python
def _solve3(root):
queue, ans = [root], 0
while any(queue):
ans = queue[0].val
queue = [
leaf for node in queue for leaf in (node.left, node.right) if leaf
]
return ans
if __name__ == '__main__':
print(_solve3(TreeNode.de_serialize('[2]')))
print(_solve3(TreeNode.de_serialize('[2,1,3]')))
print(_solve3(TreeNode.de_serialize('[1,2,3,4,null,5,6,null,null,7]')))
_deep(node.left, cur_result)
_deep(node.right, cur_result)
result = {}
_deep(root, result)
return ans[0]
def _solve1(root, sum):
def _helper(root, cur_sum):
if root:
cur_sum = cur_sum + root.val
ans = pre_sum.get(cur_sum - target, 0)
pre_sum[cur_sum] = pre_sum.get(cur_sum, 0) + 1
ans += _helper(root.left, cur_sum)
ans += _helper(root.right, cur_sum)
pre_sum[cur_sum] -= 1
return ans
else:
return 0
pre_sum = {0: 1}
target = sum
return _helper(root, 0)
if __name__ == '__main__':
node = TreeNode.de_serialize("[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1")
print(_solve1(node, 4))
print(_solve1(TreeNode.de_serialize('[1,2,null,3,null,4,null,5]'), 9))
return _help(t1, t2)
if t1 and not t2:
return t1
if t2 and not t1:
return t2
return None
def _solve1(t1, t2):
def _help(t1, t2):
if not t1:
return t2
if not t2:
return t1
t1.val += t2.val
t1.left = _help(t1.left, t2.left)
t1.right = _help(t1.right, t2.right)
return t1
return _help(t1, t2)
if __name__ == '__main__':
print(_solve1(None, None))
_solve1(TreeNode.de_serialize('[1,3,2,5]'), None).print_tree()
_solve1(None, TreeNode.de_serialize('[2,1,3,null,4,null,7]')).print_tree()
_solve1(TreeNode.de_serialize('[1,3,2,5]'),
TreeNode.de_serialize('[2,1,3,null,4,null,7]')).print_tree()
_solve1(TreeNode.de_serialize('[2,1,3,null,4,null,7]'),
TreeNode.de_serialize('[1,3,2,5]')).print_tree()
_in_order(cur.right, False))
return _in_order(t, True) in _in_order(s, True)
def _solve3(s, t):
def _post_order(cur):
return '$' if cur is None else (_post_order(cur.left) +
_post_order(cur.right) + str(cur.val) +
'^')
return _post_order(t) in _post_order(s)
if __name__ == '__main__':
print _solve2(TreeNode.de_serialize('[3,4,5,1,2,null,null,0]'),
TreeNode.de_serialize('[4,1,2]'))
print _solve(None, None)
print _solve(TreeNode.de_serialize('[3,4,5,1,2]'), None)
print _solve(TreeNode.de_serialize('[3,4,5,1,2]'),
TreeNode.de_serialize('[4,1,2]'))
print _solve(TreeNode.de_serialize('[3,4,5,1,2,null,null,null,null,0]'),
TreeNode.de_serialize('[4,1,2]'))
print _solve(
TreeNode.de_serialize(
'[1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,2]'
), TreeNode.de_serialize('[1,null,1,null,1,null,1,null,1,null,1,2]'))
print '---'
print _solve2(None, None)
print _solve2(TreeNode.de_serialize('[3,4,5,1,2]'), None)
"""Print Binary Tree.
>>> solve = _solve
>>> solve()
"""
def _solve(root):
def _compute_depth(root):
return 1 + max(_compute_depth(root.left), _compute_depth(root.right)) if root else 0
depth = _compute_depth(root)
width = (1 << depth) - 1
ans = [[""] * width for _ in xrange(depth)]
def _dfs(root, pos, cur_depth):
if root:
half_width = (1 << (depth - cur_depth - 1)) / 2
ans[cur_depth][pos] = str(root.val)
_dfs(root.left, pos - half_width, cur_depth + 1)
_dfs(root.right, pos + half_width, cur_depth + 1)
_dfs(root, width / 2, 0)
return ans
from TreeNode import TreeNode
print _solve(TreeNode.de_serialize('[1, 2]'))
print _solve(TreeNode.de_serialize('[1,2,5,3,null,null,null,4]'))
if node_left and not node_right:
return False
if not node_left and node_right:
return False
return True
def _solve1(root):
def _help(left, right):
if not left and not right:
return True
if None in (left, right):
return False
return left.val == right.val and\
_help(left.left, right.right) and _help(left.right, right.left)
return _help(root.left, root.right) if root else True
if __name__ == '__main__':
symmetric_tree = TreeNode.de_serialize('[1,2,2,3,4,4,3]')
print(_solve1(symmetric_tree))
no_symmetric_tree = TreeNode.de_serialize('[1,2,2,null,3,null,3]')
print(_solve1(no_symmetric_tree))
no_symmetric_tree = TreeNode.de_serialize('[1,2,2,3,null,3,null]')
print(_solve1(no_symmetric_tree))
no_symmetric_tree = TreeNode.de_serialize('[1,2,2,4,null,null,3]')
print(_solve1(no_symmetric_tree))
print(_solve1(TreeNode(1)))
print(_solve1(None))
result = [None, 0, 0]
CUR_VAL = 0
COUNT = 1
MAX_COUNT = 2
def _help(root):
if not root:
return
_help(root.left)
if root.val == result[CUR_VAL]:
result[COUNT] += 1
else:
result[COUNT] = 1
result[CUR_VAL] = root.val
if result[MAX_COUNT] < result[COUNT]:
result[MAX_COUNT] = result[COUNT]
while len(ans):
ans.pop()
ans.append(root.val)
elif result[MAX_COUNT] == result[COUNT]:
ans.append(root.val)
_help(root.right)
_help(root)
return ans
if __name__ == '__main__':
root = TreeNode.de_serialize('[2,null,2,2,1,2,1,1]')
print(_solve1(root))
# coding=utf-8
"""Minimum Depth of Binary Tree."""
from TreeNode import TreeNode
def _solve(root):
def _help(root):
if root:
if not root.left and not root.right:
return 1
else:
return min(_help(root.left), _help(root.right)) + 1
else:
return 1 << 30
return _help(root) if root else 0
if __name__ == '__main__':
print _solve(None)
print _solve(TreeNode(1))
print _solve(TreeNode.de_serialize('[1,23,4,5,null,5,null]'))
# coding=utf-8
"""House Robber III."""
from TreeNode import TreeNode
def _solve(root):
def _dfs(cur):
if cur:
left, right = _dfs(cur.left), _dfs(cur.right)
return cur.val + left[1] + right[1], max(left) + max(right)
else:
return 0, 0
return max(_dfs(root))
assert _solve(TreeNode.de_serialize('[3,2,3,null,3,null,1]')), 7
assert _solve(TreeNode.de_serialize('[3,4,5,1,3,null,1]')), 9
# coding=utf-8
"""Path Sum."""
from TreeNode import TreeNode
def _solve(root, sum):
def _help(root, cur):
if root:
if not root.left and not root.right:
return cur + root.val == sum
else:
return _help(root.left, cur + root.val) or _help(root.right, cur + root.val)
else:
return False
return _help(root, 0) if root else False
if __name__ == '__main__':
# ROOT = TreeNode.de_serialize('[1,2]')
# print _solve(ROOT, 1)
ROOT = TreeNode.de_serialize('[5,4,8,11,null,13,4,7,2,null,null,null,1]')
print _solve(ROOT, 22)
# print _solve(None, 1)
# print _solve(None, 0)
# coding=utf-8
"""Binary Tree Tilt."""
from TreeNode import TreeNode
def _solve(root):
def _help(root):
if root:
left_result = _help(root.left)
right_result = _help(root.right)
return (left_result[0] + right_result[0] +
abs(left_result[1] - right_result[1]),
left_result[1] + right_result[1] + root.val)
else:
return 0, 0
return _help(root)[0]
if __name__ == '__main__':
root = TreeNode.de_serialize('[1,123,124,12,43,678,123,5678,123]')
print(_solve(root))
print(_solve(None))
print(_solve(TreeNode(1)))
def _solve(root):
if not root:
return []
layer = 0
ans = []
layer_nodes = []
queue = [(root, layer)]
while len(queue):
cur = queue.pop(0)
cur_node = cur[0]
cur_layer = cur[1]
if cur_layer > layer:
layer = cur_layer
ans.append([node.val for node in layer_nodes])
layer_nodes = [cur_node]
else:
layer_nodes.append(cur_node)
if cur_node.left:
queue.append((cur_node.left, cur_layer + 1))
if cur_node.right:
queue.append((cur_node.right, cur_layer + 1))
ans.append([node.val for node in layer_nodes])
return ans[::-1]
if __name__ == '__main__':
print (_solve(None))
print (_solve(TreeNode(1)))
tree = TreeNode.de_serialize('[3,9,20,null,null,15,7]')
print (_solve(tree))
# coding=utf-8
"""Binary Tree Paths."""
from TreeNode import TreeNode
def _solve(root):
ans = []
if not root:
return ans
def _help(root, path):
if root:
path += '->' + str(root.val)
if not root.left and not root.right:
ans.append(path[2:])
_help(root.left, path)
_help(root.right, path)
_help(root, '')
return ans
if __name__ == '__main__':
ROOT = TreeNode.de_serialize('[1,2,3,3,5,12,2]')
print _solve(ROOT)
ROOT = TreeNode.de_serialize('[1]')
print _solve(ROOT)
print _solve(None)
if k == res[0]:
res[1] = cur.val
return
_dfs(cur.right)
_dfs(root)
return res[1]
def _solve1(root, k):
def _count_nodes(cur):
if cur:
return 1 + _count_nodes(cur.left) + _count_nodes(cur.right)
else:
return 0
def _dfs(cur, count):
left_count = _count_nodes(cur.left)
if count <= left_count:
return _dfs(cur.left, count)
elif count == left_count + 1:
return cur.val
else:
return _dfs(cur.right, count - 1 - left_count)
return _dfs(root, k)
assert [_solve1(TreeNode.de_serialize('[2,1,3]'), i)
for i in xrange(1, 4)], [1, 2, 3]
# coding=utf-8
"""Lowest Common Ancestor of a Binary Search Tree."""
from __future__ import print_function
from TreeNode import TreeNode
def _solve(root, p, q):
def _help(root):
if p.val < root.val > q.val:
return _help(root.left)
elif p.val > root.val < q.val:
return _help(root.right)
return root
return _help(root)
if __name__ == '__main__':
root = TreeNode.de_serialize('[6,2,8,0,4,7,8,null,null,3,5]')
print (_solve(root, TreeNode(2), TreeNode(2)).val)
print (_solve(root, TreeNode(2), TreeNode(8)).val)
print (_solve(root, TreeNode(7), TreeNode(9)).val)
print (_solve(root, TreeNode(3), TreeNode(9)).val)
# coding=utf-8
"""Convert BST to Greater Tree. """
from TreeNode import TreeNode
def _solve(root):
greater = [0]
def _in_order(cur):
if cur:
_in_order(cur.right)
cur.val += greater[0]
greater[0] = cur.val
_in_order(cur.left)
_in_order(root)
return root
_solve(TreeNode.de_serialize('[5,2,8,1,3,6,9]')).print_tree()
from TreeNode import TreeNode
def _solve(root):
ans = [True]
def _help(root):
if not root:
return 0
if root:
left_depth = _help(root.left)
right_depth = _help(root.right)
if abs(left_depth - right_depth) > 1:
ans[0] = False
return max(left_depth, right_depth) + 1
_help(root)
return ans[0]
if __name__ == '__main__':
ROOT = None
print _solve(ROOT)
ROOT = TreeNode.de_serialize('[1]')
print _solve(ROOT)
ROOT = TreeNode.de_serialize('[1,2,null]')
print _solve(ROOT)
ROOT = TreeNode.de_serialize('[1,2,null,1]')
print _solve(ROOT)
