def build(minVal, maxVal): if vals and minVal < vals[0] < maxVal: val = vals.popleft() node = TreeNode(val) node.left = build(minVal, val) node.right = build(val, maxVal) return node
def tree(lo, hi): if lo > hi: return None mid = (lo + hi) // 2 ans = TreeNode(value[mid]) ans.left = tree(lo, mid - 1) ans.right = tree(mid + 1, hi) return ans
def sortedListToBST_nlogn(self, head: ListNode) -> TreeNode: if not head: return None def getMid(node): if not node: return None if not node.next: return node prev = None slow, fast = node, node while fast and fast.next: prev = slow slow = slow.next fast = fast.next.next if prev: prev.next = None return slow mid = getMid(head) root = TreeNode(mid.val) if head == mid: return root root.left = self.sortedListToBST(head) root.right = self.sortedListToBST(mid.next) return root
def dfs(nodes): if not nodes: return None val = nodes.pop(0) if val == '#': return None node = TreeNode(int(val)) node.left = dfs(nodes) node.right = dfs(nodes) return node
def dfs(l, r): # r not include if l >= r: return None mid = (l + r) // 2 root = TreeNode(nums[mid]) root.left = dfs(l, mid) root.right = dfs(mid + 1, r) return root
def dfs(l, r): if l >= r: return None mid = (l + r) // 2 node = TreeNode(values[mid]) # Recursively form BST on the two halves node.left = dfs(l, mid) node.right = dfs(mid + 1, r) return node
def mergeTrees(self, root1: TreeNode, root2: TreeNode) -> TreeNode: if not root1 and not root2: return if not root1: return root2 if not root2: return root1 root = TreeNode(root1.val + root2.val) root.left = self.mergeTrees(root1.left, root2.left) root.right = self.mergeTrees(root1.right, root2.right) return root
def invertTree(self, root: TreeNode) -> TreeNode: if not root: return left = root.left right = root.right root.left = right root.right = left self.invertTree(root.left) self.invertTree(root.right) return root
def dfs(nodes, lb, rb): if not nodes: return None if lb < nodes[0] < rb: # this is good val = nodes.pop(0) root = TreeNode(val) root.left = dfs(nodes, lb, val) root.right = dfs(nodes, val, rb) return root return None
def dfs(N): if N == 1: return [TreeNode(0)] # base case res = [] for i in range(N): # pick up a root # all possible left subtrees if i is choosen to be a root left = dfs(i) # all possible right subtrees if i is choosen to be a root right = dfs(N - 1 - i) # connect left and right subtrees to the root i for l in left: for r in right: curr = TreeNode(0) curr.left = l curr.right = r res.append(curr) return res
def dfs(start, end): if start > end: return [None] res = [] for i in range(start, end + 1): # pick up a root # all possible left subtrees if i is choosen to be a root left = dfs(start, i - 1) # all possible right subtrees if i is choosen to be a root right = dfs(i + 1, end) # connect left and right subtrees to the root i for l in left: for r in right: curr = TreeNode(i) curr.left = l curr.right = r res.append(curr) return res
def deserialize_bfs(self, data): """Decodes your encoded data to tree. :type data: str :rtype: TreeNode """ if not data: return None nodes = data.split(',') root = TreeNode(int(nodes.pop(0))) queue = [root] while queue: curr = queue.pop(0) left_val = nodes.pop(0) right_val = nodes.pop(0) curr.left = TreeNode(int(left_val)) if left_val != '#' else None curr.right = TreeNode(int(right_val)) if right_val != '#' else None if curr.left: queue.append(curr.left) if curr.right: queue.append(curr.right) return root
def increasingBST(self, root: TreeNode) -> TreeNode: def dfs(node): nonlocal curr if not node: return dfs(node.left) node.left = None curr.right = node curr = node dfs(node.right) dummy = curr = TreeNode(None) dfs(root) return dummy.right
def recoverTree(self, root: TreeNode) -> None: """ Do not return anything, modify root in-place instead. """ self.first, self.second = None, None self.prev = TreeNode(float('-inf')) def inorder(node): if not node: return inorder(node.left) # inorder traversal left if node.val < self.pre.val: if not self.first: self.first = self.prev self.second = node self.prev = node inorder(node.right) # inorder traversal right inorder(root) self.first.val, self.second.val = self.second.val, self.first.val
return res def postorder_divide_conquer(node: 'TreeNode'): if not node: return [] res = [] res += postorder_divide_conquer(node.left) res += postorder_divide_conquer(node.right) res.append(node.val) return res if __name__ == '__main__': root = TreeNode(2) root.left, root.right = TreeNode(1), TreeNode(3) root.left.left, root.left.right = TreeNode(4), TreeNode(5) print(f'preorder_traversal_recursion results: {preorder_traversal_recursion(root)}') print(f'preorder_traversal_iterative results {preorder_traversal_iterative(root)}') print(f'preorder_divide_conquer running {preorder_divide_conquer(root)}') print(f'inorder_traversal_recursion results: {inorder_traversal_recursion(root)}') print(f'inorder_traversal_iterative results: {inorder_traversal_iterative(root)}') print(f'inorder_divide_conqur results: {inorder_divide_conquer(root)}') print(f'postorder_traversal_recursion results: {postorder_traversal_recursion(root)}') print(f'postorder_traversal_iterative results: {postorder_traversal_iterative(root)}') print(f'postorder_traversal_iterative2 results: {postorder_traversal_iterative2(root)}') print(f'postorder_divide_conqur results: {postorder_divide_conquer(root)}')