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 traverse(it):
v = next(it)
if v == "#":
return None
node = TreeNode(v)
node.left = traverse(it)
node.right = traverse(it)
return node
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 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_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 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 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_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 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_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 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 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 allPossibleFBT(self, N):
if N == 1:
return [TreeNode(0)]
res = []
for i in range(1, N, 2):
for left_root, right_root in product(
self.allPossibleFBT(i), self.allPossibleFBT(N - 1 - i)):
root = TreeNode(0)
root.left, root.right = left_root, right_root
res.append(root)
return res
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 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 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 addOneRow(self, root, v, d):
if d == 1:
node = TreeNode(v)
node.left = root
return node
from queue import Queue
q = Queue()
q.put((root, 1))
while not q.empty():
n, depth = q.get()
if depth == d - 1:
left_node, right_node = TreeNode(v), TreeNode(v)
left_node.left, right_node.right = n.left, n.right
n.left, n.right = left_node, right_node
else:
if n.left:
q.put((n.left, depth + 1))
if n.right:
q.put((n.right, depth + 1))
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_94_inorderTraversal(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, 2, 5, 1, 6, 3, 7],
self.solution._94_inorderTraversal(root))
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))
def test_144_preorderTraversal(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([1, 2, 4, 5, 3, 6, 7],
self.solution._144_preorderTraversal(root))
def test_103_zigzagLevelOrder(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)
expected = [[1], [3, 2], [4, 5, 6, 7]]
self.assertEqual(expected, self.solution._103_zigzagLevelOrder(root))
def sortedListToBST(self, head: ListNode) -> TreeNode:
if not head:
return None
if not head.next:
return TreeNode(head.val)
if not head.next.next:
root = TreeNode(head.next.val)
root.left = TreeNode(head.val)
return root
# p1 is the one before the middle node.
p1, p2 = head, head.next.next
while p2 and p2.next:
p2 = p2.next.next
p1 = p1.next
root = TreeNode(p1.next.val)
root.right = self.sortedListToBST(p1.next.next)
p1.next = None
root.left = self.sortedListToBST(head)
return root
def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
if not postorder:
return None
root = TreeNode(postorder[-1])
left_tree_size = inorder.index(postorder[-1])
left_postorder = postorder[:left_tree_size]
right_postorder = postorder[left_tree_size:-1]
left_inorder = inorder[:left_tree_size]
right_inorder = inorder[left_tree_size + 1:]
root.left = self.buildTree(left_inorder, left_postorder)
root.right = self.buildTree(right_inorder, right_postorder)
return root
