def binary_tree_from_preorder_inorder(preorder: List[int],
inorder: List[int]) -> BinaryTreeNode:
if len(preorder) == 0:
return None
root_data = preorder[0]
root_node = BinaryTreeNode(root_data)
root_pos_inorder = inorder.index(root_data)
# No left sub-tree
if root_pos_inorder == 0:
left_inorder = []
right_inorder = inorder[1:]
left_preorder = []
right_preorder = preorder[1:]
# No right sub-tree
elif root_pos_inorder == len(inorder) - 1:
left_inorder = inorder[:-1]
right_inorder = []
left_preorder = preorder[1:]
right_preorder = []
# Both left and right
else:
left_inorder = inorder[:root_pos_inorder]
right_inorder = inorder[root_pos_inorder + 1:]
left_preorder = preorder[1:1 + len(left_inorder)]
right_preorder = preorder[1 + len(left_inorder):]
root_node.left = binary_tree_from_preorder_inorder(left_preorder,
left_inorder)
root_node.right = binary_tree_from_preorder_inorder(
right_preorder, right_inorder)
return root_node
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 binary_tree_from_preorder_inorder(preorder, inorder):
if inorder:
idx = inorder.index(preorder.pop(0))
root = BinaryTreeNode(inorder[idx])
root.left = binary_tree_from_preorder_inorder(preorder, inorder[:idx])
root.right = binary_tree_from_preorder_inorder(preorder,
inorder[idx + 1:])
return root
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 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(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():
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 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 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 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 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 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):
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 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 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 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 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 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 binary_tree_from_preorder_inorder(
preorder: List[int], inorder: List[int]) -> Optional[BinaryTreeNode]:
if not preorder:
return None
root_val = preorder[0]
root = BinaryTreeNode(root_val)
in_order_root_index = inorder.index(root_val)
preorder_left = preorder[1:(1 + in_order_root_index)]
inorder_left = inorder[:in_order_root_index]
root.left = binary_tree_from_preorder_inorder(preorder_left, inorder_left)
preorder_right = preorder[(1 + in_order_root_index):]
inorder_right = inorder[(1 + in_order_root_index):]
root.right = binary_tree_from_preorder_inorder(preorder_right,
inorder_right)
return root
def helper(lower = float('-inf'), upper = float('inf')):
nonlocal idx
# if all elements from preorder are used
# then the tree is constructed
if idx == n:
return None
val = preorder[idx]
# if the current element
# couldn't be placed here to meet BST requirements
print ("val: ",val,"(val < lower) ",(val < lower) ,"(val > upper) ",(val > upper))
if val < lower or val > upper:
return None
# place the current element
# and recursively construct subtrees
idx += 1
root = BinaryTreeNode(val)
root.left = helper(lower, val)
root.right = helper(val, upper)
return root
def helper(in_left = 0, in_right = len(inorder)):
nonlocal pre_idx
# if there is no elements to construct subtrees
if in_left == in_right:
return None
# pick up pre_idx element as a root
root_val = preorder[pre_idx]
root = BinaryTreeNode(root_val)
# root splits inorder list
# into left and right subtrees
index = idx_map[root_val]
print("in_left: ",in_left,"in_right: ",in_right,"root_val: ",root_val,"index: ",index)
# recursion
pre_idx += 1
# build left subtree
root.left = helper(in_left, index)
# build right subtree
root.right = helper(index + 1, in_right)
return root
def fill_tree(node: BinaryTreeNode, lookup: Dict[int,
int], preorder: List[int],
inorder: List[int], start: int, end: int) -> None:
if preorder:
head_idx = lookup[node.data]
left_subtree_size = head_idx - start
right_subtree_size = end - start - left_subtree_size
#print("left size = {} right size = {}".format(left_subtree_size, right_subtree_size))
#print("start = {} end = {} head={}".format(start, end, head_idx))
#print(preorder)
if left_subtree_size > 0:
# insert as left child
node.left = BinaryTreeNode(preorder[0])
if left_subtree_size > 1:
fill_tree(node.left, lookup, preorder[1:left_subtree_size],
inorder, start, head_idx - 1)
if right_subtree_size > 0:
# insert as right child
node.right = BinaryTreeNode(preorder[left_subtree_size])
if right_subtree_size > 1:
fill_tree(node.right, lookup, preorder[left_subtree_size + 1:],
inorder, head_idx + 1, end)
def helper(pre_order: List[int],
in_order: List[int]) -> Optional[BinaryTreeNode]:
if len(pre_order) == 0 or len(in_order) == 0:
return None
root = pre_order[0]
# find the root in the in_order list
# Everything to the left of that index is the in-order traversal for
# the left subtree, everything to the right is the traversal for the
# right subtree
in_order_root_idx = in_order.index(root)
left_in_order = in_order[:in_order_root_idx]
right_in_order = in_order[in_order_root_idx + 1:]
num_left_elements = in_order_root_idx
# We also know that the root_idx - 1 elements are the left subtree
# pre-order traversal, and the remainder are the right subtree
# pre-order traversal
left_pre_order = pre_order[1:num_left_elements + 1]
right_pre_order = pre_order[num_left_elements + 1:]
node = BinaryTreeNode(root)
node.left = helper(left_pre_order, left_in_order)
node.right = helper(right_pre_order, right_in_order)
return node
from binary_tree_node import BinaryTreeNode
def is_symmetric(tree):
def helper(t1, t2):
if not t1 and not t2: return True
elif t1 and t2:
return t1.data == t2.data and helper(t1.left, t2.right) and helper(
t1.right, t2.left)
return False
return not tree or helper(tree.left, tree.right)
tree = BinaryTreeNode()
assert is_symmetric(tree)
tree.left = BinaryTreeNode(2)
tree.right = BinaryTreeNode(2)
assert is_symmetric(tree)
tree.left.right = BinaryTreeNode(3)
tree.right.left = BinaryTreeNode(3)
assert is_symmetric(tree)
return None # size field # 6 # 2 3 # 1 1 1 # # data field # 3 # 2 5 # 1 4 6 root = BinaryTreeNode() root.size = 6 root.data = 3 root.left = BinaryTreeNode() root.left.size = 2 root.left.data = 2 root.left.left = BinaryTreeNode() root.left.left.size = 1 root.left.left.data = 1 root.right = BinaryTreeNode() root.right.size = 3 root.right.data = 5 root.right.left = BinaryTreeNode() root.right.left.size = 1 root.right.left.data = 4 root.right.right = BinaryTreeNode() root.right.right.size = 1 root.right.right.data = 6
