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