def recur(low, high):
if low > high: return None
x = TreeNode(postorder.pop())
mid = map_inorder[x.val]
x.right = recur(mid + 1, high)
x.left = recur(low, mid - 1)
return x
def build(stop):
if inorder and inorder[-1] != stop:
root = TreeNode(preorder.pop())
root.left = build(root.val)
inorder.pop()
root.right = build(stop)
return root
def test_amazon(self):
s = Solution()
self.assertEqual(True, s.isValidBST(TreeNode.generate([2, 1, 3])))
self.assertEqual(
False, s.isValidBST(TreeNode.generate([5, 1, 4, None, None, 3,
6])))
def deserialize(self, data):
"""Decodes your encoded data to tree.
:type data: str
:rtype: TreeNode
"""
nodes = data.split(',')
value = nodes.pop(0)
if value == 'null':
return None
root = TreeNode(int(value))
queue = [root]
i = 1
while nodes:
tree_node = queue.pop(0)
value = nodes.pop(0)
if value == 'null':
tree_node.left = None
else:
tree_node.left = TreeNode(int(value))
value = nodes.pop(0)
if value == 'null':
tree_node.right = None
else:
tree_node.right = TreeNode(int(value))
if tree_node.left:
queue.append(tree_node.left)
if tree_node.right:
queue.append(tree_node.right)
return root
# Your Codec object will be instantiated and called as such:
# codec = Codec()
# codec.deserialize(codec.serialize(root))
def buildTree(self, preorder, inorder):
if inorder:
idx = inorder.index(preorder.pop(0))
root = TreeNode(inorder[idx])
root.left = self.buildTree(preorder, inorder[0:idx])
root.right = self.buildTree(preorder, inorder[idx + 1:])
return root
def bst_from_preorder(self, A):
if not A: return None
root = TreeNode(A[0])
i = bisect.bisect(A, A[0])
root.left = self.bst_from_preorder(A[1:i])
root.right = self.bst_from_preorder(A[i:])
return root
def trimBST1(self, root: 'TreeNode', L: int, R: int) -> 'TreeNode':
dummy = TreeNode(float('inf'))
dummy.left = root
print(root)
# default: cur is valid
def dfs(cur):
if not cur:
return
while cur.right and cur.right.val > R:
cur.right = cur.right.left
while cur.right and cur.right.val < L:
cur.right = cur.right.right
while cur.left and cur.left.val > R:
cur.left = cur.left.left
while cur.left and cur.left.val < L:
cur.left = cur.left.right
dfs(cur.left)
dfs(cur.right)
dfs(dummy)
return dummy.left
def invertTree(self, root: TreeNode) -> TreeNode:
if not root:
return None
left = self.invertTree(root.left)
right = self.invertTree(root.right)
root.left = right
root.right = left
return root
def test_diameter_of_binary_tree(self):
s = Solution()
self.assertEqual(
3, s.diameterOfBinaryTree(TreeNode.generate([1, 2, 3, 4, 5])))
self.assertEqual(0, s.diameterOfBinaryTree(TreeNode.generate([])))
self.assertEqual(0, s.diameterOfBinaryTree(TreeNode.generate([1])))
self.assertEqual(1, s.diameterOfBinaryTree(TreeNode.generate([1, 2])))
def f(self, inorder: list, postorder: list):
index = inorder.index(postorder[-1])
node = TreeNode(postorder[-1])
if index > 0:
node.left = self.f(inorder[:index], postorder[:index])
if index < len(inorder) - 1:
node.right = self.f(inorder[index + 1:], postorder[index:-1])
return node
def helper(i, j):
if i == j:
return None
root = TreeNode(A[i])
mid = bisect.bisect(A, A[i], i + 1, j)
root.left = helper(i + 1, mid)
root.right = helper(mid, j)
return root
def test_sum_of_left_leaves(self):
s = Solution()
self.assertEqual(0, s.sumOfLeftLeaves(TreeNode.generate([1])))
self.assertEqual(
24,
s.sumOfLeftLeaves(TreeNode.generate([3, 9, 20, None, None, 15,
7])))
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
if not nums:
return None
middle = len(nums) // 2
root = TreeNode(nums[middle])
root.left = self.sortedArrayToBST(nums[:middle])
root.right = self.sortedArrayToBST(nums[middle + 1:])
return root
def test_symmetric_tree(self):
s = Solution()
self.assertEqual(
True, s.isSymmetric(TreeNode.generate([1, 2, 2, 3, 4, 4, 3])))
self.assertEqual(
False, s.isSymmetric(TreeNode.generate([1, 2, 2, None, 3, None,
3])))
def sortedArrayToBST(self, nums):
if not nums:
return None
mid = len(nums) // 2
root = TreeNode(nums[mid])
root.left = self.sortedArrayToBST(nums[:mid])
root.right = self.sortedArrayToBST(nums[mid + 1:])
return root
def f(self, l: list):
mid = (len(l) - 1) // 2
node = TreeNode(l[mid])
if mid > 0:
node.left = self.f(l[:mid])
if mid < len(l) - 1:
node.right = self.f(l[mid + 1:])
return node
def traverse(it):
v = next(it)
if v == "#":
return None
node = TreeNode(v)
node.left = traverse(it)
node.right = traverse(it)
return node
def test_balanced_binary_tree(self):
s = Solution()
self.assertEqual(
True, s.isBalanced(TreeNode.generate([3, 9, 20, None, None, 15,
7])))
self.assertEqual(
False,
s.isBalanced(TreeNode.generate([1, 2, 2, 3, 3, None, None, 4, 4])))
def buildTree(self, preorder: 'List[int]',
inorder: 'List[int]') -> 'TreeNode':
if not preorder:
return None
index = inorder.index(preorder[0])
root = TreeNode(preorder[0])
root.left = self.buildTree(preorder[1:index + 1], inorder[0:index])
root.right = self.buildTree(preorder[index + 1:], inorder[index + 1:])
return root
def mergeTrees(self, t1: 'TreeNode', t2: 'TreeNode') -> 'TreeNode':
if not t1 and not t2:
return None
t = TreeNode((t1.val if t1 else 0) + (t2.val if t2 else 0))
t.left = self.mergeTrees(t1.left if t1 else None,
t2.left if t2 else None)
t.right = self.mergeTrees(t1.right if t1 else None,
t2.right if t2 else None)
return t
def test_microsoft(self):
s = Solution()
self.assertEqual(2, s.inorderSuccessor(TreeNode.generate([2, 1, 3]),
1))
self.assertEqual(
None,
s.inorderSuccessor(
TreeNode.generate([[5, 3, 6, 2, 4, None, None, 1]]), 6))
def generate(first, last):
trees = []
for root in range(first, last + 1):
for left in generate(first, root - 1):
for right in generate(root + 1, last):
node = TreeNode(root)
node.left = left
node.right = right
trees += (node,)
return trees or [None]
def test_104_maxDepth(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(2)
root.left.left = TreeNode(3)
root.left.right = TreeNode(4)
root.right.right = TreeNode(3)
root.right.right.right = TreeNode(3)
self.assertEqual(4, self.solution._104_maxDepth(root))
def test_binary_tree_level_order_traversal_ii(self):
s = Solution1()
self.assertEqual([[15, 7], [9, 20], [3]],
s.levelOrderBottom(
TreeNode.generate([3, 9, 20, None, None, 15, 7])))
self.assertEqual([], s.levelOrderBottom(TreeNode.generate([])))
self.assertEqual([[4, 5], [2, 3], [1]],
s.levelOrderBottom(TreeNode.generate([1, 2, 3, 4,
5])))
def constructMaximumBinaryTree(self, nums):
if not nums:
return None
max_num = max(nums)
max_pos = nums.index(max_num)
node = TreeNode(max_num)
node.left, node.right = self.constructMaximumBinaryTree(
nums[:max_pos]), self.constructMaximumBinaryTree(nums[max_pos +
1:])
return node
def test_100_isSameTree(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.right.left = TreeNode(6)
root.right.right = TreeNode(7)
self.assertEqual(True, self.solution._100_isSameTree(root, root))
def test_101_isSymmetric(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(2)
root.left.left = TreeNode(3)
root.left.right = TreeNode(4)
root.right.left = TreeNode(4)
root.right.right = TreeNode(3)
self.assertEqual(True, self.solution._101_isSymmetric(root))
def mergeTrees(self, t1: 'TreeNode', t2: 'TreeNode') -> 'TreeNode':
if t1 is None:
return t2
if t2 is None:
return t1
root = TreeNode(t1.val + t2.val)
root.left = self.mergeTrees(t1.left, t2.left)
root.right = self.mergeTrees(t1.right, t2.right)
return root
def test_107_levelOrderBottom(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.right.left = TreeNode(6)
root.right.right = TreeNode(7)
self.assertEqual([[4, 5, 6, 7], [2, 3], [1]],
self.solution._107_levelOrderBottom(root))
def constructMaximumBinaryTree(self, nums):
index = nums.index(max(nums))
f_half = nums[:index]
s_half = nums[index + 1:]
node = TreeNode(nums[index])
if (len(f_half) > 0):
node.left = self.constructMaximumBinaryTree(f_half)
if (len(s_half) > 0):
node.right = self.constructMaximumBinaryTree(s_half)
return node
