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)