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