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 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 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 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_129_sumNumbers(self):
root = TreeNode(4)
root.left = TreeNode(9)
root.right = TreeNode(0)
root.left.left = TreeNode(5)
root.left.right = TreeNode(1)
self.assertEqual(1026, self.solution._129_sumNumbers(root))
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 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_112_hasPathSum(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.right.left = TreeNode(6)
root.right.right = TreeNode(7)
self.assertEqual(True, self.solution._112_hasPathSum(root, 11))
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 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_111_minDepth(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.right.left = TreeNode(6)
root.right.right = TreeNode(7)
self.assertEqual(2, self.solution._111_minDepth(root))
def traverse(it):
v = next(it)
if v == "#":
return None
node = TreeNode(v)
node.left = traverse(it)
node.right = traverse(it)
return node
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 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 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 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_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_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 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_find_largest_value_in_each_tree_row(self):
s = Solution()
root = TreeNode(1)
root.left = TreeNode(3)
root.left.left = TreeNode(5)
root.left.right = TreeNode(3)
root.right = TreeNode(2)
root.right.right = TreeNode(9)
self.assertEqual([1, 3, 9], s.largestValues(root))
def test_110_isBalanced(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.right.right = TreeNode(7)
self.assertTrue(self.solution._110_isBalanced(root))
root.right.right.right = TreeNode(8)
self.assertFalse(self.solution._110_isBalanced(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
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_98_isValidBST(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.assertFalse(self.solution._98_isValidBST(root))
def sortedArrayToBST(self, nums):
"""
:type nums: List[int]
:rtype: TreeNode
"""
if not nums:
return None
mid = len(nums) // 2
node = TreeNode(nums[mid])
node.left = self.sortedArrayToBST(nums[:mid])
node.right = self.sortedArrayToBST(nums[mid + 1:])
return node
def buildTree(self, inorder, postorder):
if not inorder or not postorder:
return None
root = TreeNode(postorder.pop())
inorderIndex = inorder.index(root.val) # Line A
root.right = self.buildTree(inorder[inorderIndex + 1:],
postorder) # Line B
root.left = self.buildTree(inorder[:inorderIndex], postorder) # Line C
return root
def generate_trees(nums: List[int]) -> List[TreeNode]:
if not nums:
return [None]
trees = []
for i, n in enumerate(nums):
for left_tree in generate_trees(nums[:i]):
for right_tree in generate_trees(nums[i + 1:]):
root = TreeNode(n)
root.left = left_tree
root.right = right_tree
trees.append(root)
return trees
def test_145_postorderTraversal(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, 2, 6, 7, 3, 1],
self.solution._145_postorderTraversal(root))
