def read(array):
c = next(array)
if c == '#':
return None
node = TreeNode(int(c))
node.left = read(array)
node.right = read(array)
return node
def build_tree_from_i_and_p(inorder, postorder):
if not inorder or not postorder:
return None
root_val = postorder[-1]
node = TreeNode(root_val)
i = inorder.index(root_val)
node.left = build_tree_from_i_and_p(inorder[:i], postorder[:i])
node.right = build_tree_from_i_and_p(inorder[i + 1:], postorder[i:-1])
return node
def build_tree_from_p_and_i(preorder, inorder):
if not inorder:
return None
root_val = preorder.pop(0)
node = TreeNode(root_val)
i = inorder.index(root_val)
node.left = build_tree_from_p_and_i(preorder, inorder[:i])
node.right = build_tree_from_p_and_i(preorder, inorder[i + 1:])
return node
def sorted_array_to_bst(nums):
nums_len = len(nums)
if nums_len == 0:
return None
middle = nums_len // 2
root = TreeNode(nums[middle])
root.left = sorted_array_to_bst(nums[:middle])
root.right = sorted_array_to_bst(nums[middle + 1:])
return root
def test_postorder_traversal(self):
"""
1
\
2
/
3
"""
node = TreeNode(1)
node.right = TreeNode(2)
node.right.left = TreeNode(3)
result = postorder_traversal(node)
self.assertEqual(result, [3, 2, 1])
def insert_into_bst(root, val):
if root is None:
return None
if root.val == val:
raise Exception('invalid val')
if root.val > val:
if root.left is None:
root.left = TreeNode(val)
else:
insert_into_bst(root.left, val)
else:
if root.right is None:
root.right = TreeNode(val)
else:
insert_into_bst(root.right, val)
return root
def test_serialize_deserialize(self):
"""
1
/ \
2 3
/ \
4 5
"""
node = TreeNode(1)
node.left = TreeNode(2)
node.left.left = TreeNode(4)
node.left.right = TreeNode(-5)
node.right = TreeNode(3)
result = deserialize(serialize(node))
self.assertEqual(result, node)
def test_level_order_traversal(self):
"""
3
/ \
9 20
/ \
15 7
"""
node = TreeNode(3)
node.left = TreeNode(9)
node.right = TreeNode(20)
node.right.left = TreeNode(15)
node.right.right = TreeNode(7)
result = level_order_traversal(node)
self.assertEqual(result, [[3], [9, 20], [15, 7]])
def test_maximum_depth(self):
"""
3
/ \
9 20
/ \
15 7
"""
node = TreeNode(3)
node.left = TreeNode(9)
node.right = TreeNode(20)
node.right.left = TreeNode(15)
node.right.right = TreeNode(7)
result = maximum_depth(node)
self.assertEqual(result, 3)
result = maximum_depth2(node, 0)
self.assertEqual(result, 3)
def test_inorder_traversal(self):
"""
1
\
2
/
3
"""
node = TreeNode(1)
node.right = TreeNode(2)
node.right.left = TreeNode(3)
result = inorder_traversal(node)
self.assertEqual(result, [1, 3, 2])
"""
1
/ \
2 3
/ \
4 5
"""
node = TreeNode(1)
node.left = TreeNode(2)
node.left.left = TreeNode(4)
node.left.right = TreeNode(5)
node.right = TreeNode(3)
result = inorder_traversal(node)
self.assertEqual(result, [4, 2, 5, 1, 3])
result = morris_inorder_traversal(node)
self.assertEqual(result, [4, 2, 5, 1, 3])
def test_lowest_common_ancestor(self):
"""
_______3______
/ \
___5__ ___1__
/ \ / \
6 _2 0 8
/ \
7 4
"""
node = TreeNode(3)
node.left = TreeNode(5)
node.left.left = TreeNode(6)
node.left.right = TreeNode(2)
node.left.right.left = TreeNode(7)
node.left.right.right = TreeNode(4)
node.right = TreeNode(1)
node.right.left = TreeNode(0)
node.right.right = TreeNode(8)
a1 = lowest_common_ancestor(node, node.left, node.right)
self.assertEqual(a1, node)
a2 = lowest_common_ancestor(node, node.left, node.left.right.right)
self.assertEqual(a2, node.left)
def test_has_path_sum(self):
"""
5
/ \
4 8
/ / \
11 13 4
/ \ \
7 2 1
"""
node = TreeNode(5)
node.left = TreeNode(4)
node.left.left = TreeNode(11)
node.left.left.left = TreeNode(7)
node.left.left.right = TreeNode(2)
node.right = TreeNode(8)
node.right.left = TreeNode(13)
node.right.right = TreeNode(4)
node.right.right.right = TreeNode(1)
result = has_path_sum(node, 22)
self.assertTrue(result)
def test_symmetric_tree(self):
"""
1
/ \
2 2
/ \ / \
3 4 4 3
"""
node = TreeNode(1)
node.left = TreeNode(2)
node.left.left = TreeNode(3)
node.left.right = TreeNode(4)
node.right = TreeNode(2)
node.right.left = TreeNode(4)
node.right.right = TreeNode(3)
result = is_symmetric_tree(node)
self.assertTrue(result)
"""
1
/ \
2 2
\ \
3 3
"""
node = TreeNode(1)
node.left = TreeNode(2)
node.left.right = TreeNode(3)
node.right = TreeNode(2)
node.right.right = TreeNode(3)
result = is_symmetric_tree(node)
self.assertFalse(result)