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