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))