def inorder(n):
if n is None: return TreeNode(val)
if val < n.val:
n.left = inorder(n.left)
else:
n.right = inorder(n.right)
return n
def dfs(l, r):
if l > r: return None
mid = (r - l) // 2 + l
root = TreeNode(nums[mid])
root.left = dfs(l, mid - 1)
root.right = dfs(mid + 1, r)
return root
def binary_tree_level_order_traversal(self, root: typing.List[int]) -> TreeNode:
root = TreeNode.deserialize(root)
if root is None: return None
sent = prev = TreeNode(0)
def inorder(node):
nonlocal prev
if node is None: return
inorder(node.left)
# process node
prev.right = node
node.left = prev
prev = node
inorder(node.right)
inorder(root)
head = sent.right
head.left = prev
prev.right = head
return head
# 1. Perform inorder traversal and create the doubly linked list on the fly
# 2. To access prev node after dfs, set prev as nonlocal variable
"""
def dfs(pl, pr, il, ir):
if pl > pr: return None
n = TreeNode(preorder[pl])
if pl == pr: return n
mid = inord_map[n.val]
n.left = dfs(pl + 1, pl + (mid - il), il, mid - 1)
n.right = dfs(pl + (mid - il) + 1, pr, mid + 1, il)
return n
def dfs(pl, pr, il, ir):
if pl > pr: return None
node = TreeNode(postorder[pr])
if pl == pr: return node
inord_mid = inord_map[node.val]
postord_mid = pr - (ir - inord_mid)
node.left = dfs(pl, postord_mid - 1, il, inord_mid - 1)
node.right = dfs(postord_mid, pr - 1, inord_mid + 1, ir)
return node
def insert_into_a_binary_search_tree(self, root: List[int],
val: int) -> TreeNode:
root = TreeNode.deserialize(root)
new_node = TreeNode(val)
if root is None: return new_node
prev = None
cur = root
while cur is not None:
prev = cur
if val < cur.val:
cur = cur.left
else:
cur = cur.right
if prev.val > val:
prev.left = new_node
else:
prev.right = new_node
return root
