def recur(low,high):
if low>high:
return None
root = BinaryTreeNode(preorder.pop())
mid = map_inorder[root.data]
root.left = recur(low,mid-1)
root.right = recur(mid+1,high)
return root
def build_min_height_bst_from_sorted_array(A):
if not A:
return None
mid = len(A) // 2
root = BinaryTreeNode(A[mid])
root.left = build_min_height_bst_from_sorted_array(A[:mid])
root.right = build_min_height_bst_from_sorted_array(A[mid + 1:])
return root
def helper(plist):
if plist[-1] is None:
plist.pop()
return None
root = BinaryTreeNode(plist.pop())
# plist.popleft()
root.left = helper(plist)
root.right = helper(plist)
return root
def helper(index, preorder):
if preorder[index[0]] is None:
return None
node = BinaryTreeNode(preorder[index[0]])
index[0] += 1
node.left = helper(index, preorder)
index[0] += 1
node.right = helper(index, preorder)
return node
def helper(preorder, inorder, dic, pi, pj, ii, ij):
if pj <= pi or ij <= ii:
return None
i = dic[preorder[pi]]
left_size = i - ii
root = BinaryTreeNode(preorder[pi])
root.left = helper(preorder, inorder, dic, pi+1, pi+1+left_size, ii, i)
root.right = helper(preorder, inorder, dic, pi+1+left_size, pj, i+1, ij)
return root
def helper():
nonlocal i
data = preorder[i]
i += 1
if data is None:
return None
node = BinaryTreeNode(data)
node.left = helper()
node.right = helper()
return node
def insert(root, val):
if val > root.val:
if root.right is None:
root.right = BinaryTreeNode(val)
else:
insert(root.right, val)
else:
if root.left is None:
root.left = BinaryTreeNode(val)
else:
insert(root.left, val)
def reconstruct_preorder(preorder):
if preorder == [None]:
return None
stack = []
for i in reversed(range(len(preorder))):
temp_data = preorder[i]
if temp_data is not None:
temp_node = BinaryTreeNode(temp_data, stack.pop(), stack.pop())
else:
temp_node = BinaryTreeNode(temp_data, None, None)
stack.append(temp_node)
return stack.pop()
def construct_tree(i):
root_val = preorder[i]
i += 1
if root_val is None:
return None, i
tree = BinaryTreeNode(root_val)
tree.left, i = construct_tree(i)
tree.right, i = construct_tree(i)
return tree, i
def reconstruct_preorder(preorder):
stack = []
for i in reversed(preorder):
if i is None:
stack.append(None)
else:
node = BinaryTreeNode(i)
node.left = stack.pop(-1)
node.right = stack.pop(-1)
stack.append(node)
return stack[0]
def recurse(istart, iend, pstart, pend):
head_val = preorder[pstart]
new_node = BinaryTreeNode(head_val)
head_idx = i_val_to_idx[head_val]
left_len = head_idx - istart
if istart < head_idx:
new_node.left = recurse(istart, head_idx - 1, pstart + 1, pstart + left_len)
if iend > head_idx:
new_node.right = recurse(head_idx + 1, iend, pstart + left_len + 1, pend)
return new_node
def helper(left, right):
if left > right:
return None
# always choose left middle node as a root
p = (left + right) // 2
# preorder traversal: node -> left -> right
root = BinaryTreeNode(nums[p])
root.left = helper(left, p - 1)
root.right = helper(p + 1, right)
return root
def binary_tree_helper(pre_new: List[int], in_new: List[int]):
if not in_new and not pre_new:
return None
node = BinaryTreeNode(pre_new[0])
if len(in_new) == 1:
return node
root_index = in_new.index(node.data)
in_left = in_new[:root_index]
in_right = in_new[root_index + 1:]
node.left = binary_tree_helper(pre_new[1:len(in_left) + 1], in_left)
node.right = binary_tree_helper(pre_new[len(in_left) + 1:], in_right)
return node
def binary_tree_from_preorder_inorder(preorder, inorder):
if len(preorder) == len(inorder) == 1:
return BinaryTreeNode(preorder[0])
elif not preorder and not inorder:
return None
mid = inorder.index(preorder[0])
new_node = BinaryTreeNode(
preorder[0],
binary_tree_from_preorder_inorder(preorder[1:mid + 1], inorder[:mid]),
binary_tree_from_preorder_inorder(preorder[mid + 1:],
inorder[mid + 1:]))
return new_node
def binary_tree_from_preorder_inorder(preorder, inorder):
if not inorder:
return None
tree = BinaryTreeNode(preorder[0])
x = inorder.index(preorder[0])
left, right = inorder[:x], inorder[x + 1:]
if left:
tree.left = binary_tree_from_preorder_inorder(
preorder[1:len(left) + 1], left)
if right:
tree.right = binary_tree_from_preorder_inorder(
preorder[len(left) + 1:], right)
return tree
def binary_tree_from_preorder_inorder(preorder, inorder):
inorder_locations = {data: i for i, data in enumerate(inorder)}
if len(preorder) == 0:
return None
root_data = preorder[0]
root = BinaryTreeNode(root_data)
inorder_left = inorder[:inorder_locations[root_data]]
inorder_right = inorder[inorder_locations[root_data] + 1:]
preorder_left = preorder[1:inorder_locations[root_data] + 1]
preorder_right = preorder[inorder_locations[root_data] + 1:]
root.left = binary_tree_from_preorder_inorder(preorder_left, inorder_left)
root.right = binary_tree_from_preorder_inorder(preorder_right,
inorder_right)
return root
def rebuild_bst_from_preorder(preorder_sequence):
if not preorder_sequence:
return None
root = BinaryTreeNode(preorder_sequence[0])
i = 1
while i < len(preorder_sequence):
if preorder_sequence[i] < preorder_sequence[0]:
i += 1
else:
break
root.left = rebuild_bst_from_preorder(preorder_sequence[1:i])
root.right = rebuild_bst_from_preorder(preorder_sequence[i:])
return root
def build_bst(left, right):
if left > right:
return None
mid = left + (right - left) // 2
left_subtree = build_bst(left, mid - 1)
right_subtree = build_bst(mid + 1, right)
return BinaryTreeNode(A[mid], left_subtree, right_subtree)
def build_tree(preorder, inorder, root, pre_idx, left, right):
root_data = preorder[pre_idx]
root.data = root_data
in_sub_arr = inorder[left:right + 1]
in_idx = in_sub_arr.index(root_data)
if in_idx > left:
node = BinaryTreeNode()
root.left = node
build_tree(preorder, inorder, root.left, pre_idx + 1, left, in_idx - 1)
if in_idx < right:
node = BinaryTreeNode()
root.right = node
build_tree(preorder, inorder, root.right, pre_idx + 1, in_idx + 1, right)
def generate_all_binary_trees_pythonic(num_nodes):
return [
BinaryTreeNode(0, left, right)
for num_left_tree_nodes in range(num_nodes)
for left in generate_all_binary_trees(num_left_tree_nodes) for right in
generate_all_binary_trees(num_nodes - 1 - num_left_tree_nodes)
] or [None]
def construct_tree(il: int, ir: int, pl: int,
pr: int) -> Optional[BinaryTreeNode]:
if ir < il:
return None
root = BinaryTreeNode(preorder[pl])
if il == ir:
return root
rootPosition = positionOf[preorder[pl]]
il_l, ir_l = il, rootPosition - 1
pl_l, pr_l = pl + 1, (rootPosition - il) + pl
leftTree = construct_tree(il_l, ir_l, pl_l, pr_l)
il_r, ir_r = rootPosition + 1, ir
pl_r, pr_r = pr_l + 1, pr
rightTree = construct_tree(il_r, ir_r, pl_r, pr_r)
root.left, root.right = leftTree, rightTree
return root
def reconstruct_preorder(preorder):
key = preorder.pop(0)
if key is None:
return None
left_subtree = reconstruct_preorder(preorder)
right_subtree = reconstruct_preorder(preorder)
return BinaryTreeNode(key, left_subtree, right_subtree)
def _reconstruct_preorder(preorder_iter):
head = next(preorder_iter)
if head is None:
return None
left = _reconstruct_preorder(preorder_iter)
right = _reconstruct_preorder(preorder_iter)
return BinaryTreeNode(head, left, right)
def construct_tree() -> Optional[BinaryTreeNode]:
nonlocal i
if i == len(preorder): return None
i += 1
if preorder[i - 1] is None:
return None
return BinaryTreeNode(preorder[i - 1], construct_tree(),
construct_tree())
def helper(pre_arr, in_arr):
if not in_arr:
return None
node = BinaryTreeNode(pre_arr.popleft())
left_in = deque([])
while val_idx[in_arr[0]] < val_idx[node.data]:
left_in.append(in_arr.popleft())
# pop current node
in_arr.popleft()
right_in = in_arr
node.left = helper(pre_arr, left_in)
node.right = helper(pre_arr, right_in)
return node
def reconstruct_preorder_helper(preorder_iter):
subtree_key = next(preorder_iter)
if subtree_key is None:
return None
left_subtree = reconstruct_preorder_helper(preorder_iter)
right_subtree = reconstruct_preorder_helper(preorder_iter)
return BinaryTreeNode(subtree_key, left_subtree, right_subtree)
def construct_tree(preorder_start, preorder_end, inorder_start, inorder_end):
if preorder_start > preorder_end or inorder_start > inorder_end:
return None
root = preorder[preorder_start]
root_inorder_idx = inorder_indexes[root]
n_left_elements = root_inorder_idx - inorder_start
tree = BinaryTreeNode(root)
tree.left = construct_tree(preorder_start + 1,
preorder_start + n_left_elements,
inorder_start,
root_inorder_idx - 1)
tree.right = construct_tree(preorder_start + n_left_elements + 1,
preorder_end,
root_inorder_idx + 1,
inorder_end)
return tree
def reconstruct(preorder_iter):
root_key = next(preorder_iter)
if root_key is None:
return None
left_subtree = reconstruct(preorder_iter)
right_subtree = reconstruct(preorder_iter)
return BinaryTreeNode(root_key, left_subtree, right_subtree)
def binary_tree_from_preorder_inorder(preorder, inorder):
if not preorder:
return None
root = BinaryTreeNode(data=preorder[0])
lookup = {}
for i, el in enumerate(inorder):
lookup[el] = i
fill_tree(root, lookup, preorder[1:], inorder, 0, len(inorder) - 1)
return root
def build_tree(iterator):
key = next(iterator)
if key is None:
return None
left = build_tree(iterator)
right = build_tree(iterator)
return BinaryTreeNode(key, left, right)
