Python build_tree Examples

Example #1

File: p109_trees_within_trees.py Project: tusharsadhwani/daily_byte

def main() -> None:
    """Main function"""
    tree = build_tree([1, 3, 8])
    subtree = build_tree([1, None, 8])
    # tree = build_tree([7, 8, 3])
    # subtree = build_tree([7, 8, 3])
    # tree = build_tree([7, 8, 3])
    # subtree = build_tree([7, 8, [3, 1, 1]])

    print(is_subtree(tree, subtree))

Example #2

File: p48_same_leaves.py Project: tusharsadhwani/daily_byte

def main() -> None:
    """Main function"""
    tree_a = build_tree([1, 1, 3])
    tree_b = build_tree([7, 1, 2])

    # tree_a = build_tree([8, 2, [29, 3, 9]])
    # tree_b = build_tree([8, [2, 2, None], [29, [3, None, 3], 9]])

    leaf_values_a = [node.value for node in tree_a.leaves()]
    leaf_values_b = [node.value for node in tree_b.leaves()]
    print(leaf_values_a == leaf_values_b)

Example #3

File: p33_identical_trees.py Project: tusharsadhwani/daily_byte

def main() -> None:
    """Main function"""
    items_a = [2, 1, 3]
    items_b = [2, 1, 3]

    # items_a = [1, None, [9, None, 18]]
    # items_b = [1, [9, None, 18], None]

    # items_a = [2, 3, 1]
    # items_b = [2, 1, 3]

    tree_a = build_tree(items_a)
    tree_b = build_tree(items_b)

    print(tree_a == tree_b)

Example #4

def main() -> None:
    """Main function"""
    tree = build_tree([1, 2, 3])
    value = 4
    # value = 7

    print(tree_pair(tree, value))

Example #5

def main() -> None:
    """Main function"""
    tree = build_tree([1, 2, 3])
    # tree = build_tree([8, 2, [29, 3, 9]])

    print(
        ['->'.join(str(val) for val in path) for path in get_leaf_paths(tree)])

Example #6

def main() -> None:
    """Main function"""
    tree = build_tree([2, 10, [15, None, 20]])
    # tree = build_tree([1, [5, 5, 3], [6, None, 7]])

    levels = level_order_traversal(tree)
    print([max(level) for level in levels])

Example #7

def main() -> None:
    """Main function"""
    tree = build_tree([2, 1, 1])
    # tree = build_tree([1, [5, None, 7], [5, None, 7]])

    inverted_tree = create_inverted_tree(tree)
    print(tree == inverted_tree)

Example #8

def main() -> None:
    """Main function"""
    bst = build_tree([2, 3, 1])
    # bst = build_tree([29, [17, 1, None], [50, 42, 59]])
    # bst = build_tree([2, None, 100])

    prev_node: Optional[NodeTree] = None
    least_difference: Optional[int] = None
    for node in bst:
        if prev_node is None:
            prev_node = node
            continue

        difference = abs(node.value - prev_node.value)

        if least_difference is None:
            least_difference = difference
            continue

        if difference < least_difference:
            least_difference = difference

        prev_node = node

    print(least_difference)

Example #9

def main() -> None:
    """Main function"""
    tree = build_tree([0, None, 3])
    # tree = build_tree([2, 1, 3])

    level_up(tree)
    tree.print_inorder()

Example #10

def main() -> None:
    """Main function"""
    tree = build_tree([4, 2, 7])
    # tree = build_tree([7, [4, 1, 4], [9, 8, [9, None, 9]]])

    levels = level_order_traversal(tree)
    print([level[0] for level in levels])

Example #11

File: p39_bottoms_up.py Project: tusharsadhwani/daily_byte

def main() -> None:
    """Main function"""
    tree = build_tree([2, 1, 2])
    # tree = build_tree([7, [6, 3, 3], 2])

    levels = level_order_traversal(tree)
    print(levels[::-1])

Example #12

def main() -> None:
    """Main function"""
    tree = build_tree([7, [2, 1, 5], 9])
    value_a, value_b = 1, 9

    # tree = build_tree([8, [3, 2, 6], 9])
    # value_a, value_b = 2, 6

    # tree = build_tree([8, 6, 9])
    # value_a, value_b = 6, 8

    _, trail_a = find_trail(tree, value_a)
    _, trail_b = find_trail(tree, value_b)

    common_trail: list[NodeTree] = []
    for node_a, node_b in zip(trail_a, trail_b):
        if node_a != node_b:
            break

        common_trail.append(node_a)

    if common_trail:
        lowest_common_ancestor = common_trail[-1]
        print(lowest_common_ancestor)
    else:
        print(None)

Example #13

File: p139_longest_consecutive_path.py Project: tusharsadhwani/daily_byte

def main() -> None:
    """Main function"""
    tree = build_tree([1, None, [2, None, 3]])
    # tree = build_tree([1, [2, 4, [3, 4, None]], [2, 5, 8]])

    max_length = max(longest_chain(node) for node in tree)
    print(max_length)

Example #14

File: p36_gather_levels.py Project: tusharsadhwani/daily_byte

def main() -> None:
    """Main function"""
    tree = build_tree([4, 2, 7])
    # tree = build_tree([2, 10, [15, None, 20]])
    # tree = build_tree([1, [9, 3, None], [32, None, 78]])

    levels = level_order_traversal(tree)
    print(levels)

Example #15

def main() -> None:
    """Main function"""
    tree = build_tree([3, 2, 4])
    index = 1
    # tree = build_tree([7, [3, None, 5], 9])
    # index = 3

    print(list(tree)[index - 1].value)

Example #16

File: p30_bst_to_linked_list.py Project: tusharsadhwani/daily_byte

def main() -> None:
    """Main function"""
    tree = build_tree([5, 1, 6])
    # tree = build_tree([5, [2, 1, 3], 9])
    # tree = build_tree([5, None, 6])

    node_list = create_node_list([node.value for node in tree])

    node_list.print()

Example #17

File: p117_bottom_of_the_barrel.py Project: tusharsadhwani/daily_byte

def main() -> None:
    """Main function"""
    tree = build_tree([1, [2, 4, None], 3])
    # tree = build_tree([8, 1, [4, 2, None]])

    bottom_level = []
    for level in level_order_traversal(tree):
        bottom_level = level

    print(bottom_level[0])

Example #18

File: p29_find_value.py Project: tusharsadhwani/daily_byte

def main() -> None:
    """Main function"""
    tree = build_tree([3, 1, 4])
    node = find_tree_node(tree, 1)

    # tree = build_tree([7, 5, [9, 8, 10]])
    # node = find_tree_node(tree, 9)

    # tree = build_tree([8, 6, 9])
    # node = find_tree_node(tree, 7)

    print(node)

Example #19

def main() -> None:
    """Main function"""
    tree = build_tree([3, 1, 8])
    num = 11
    # tree = build_tree([2, [-4, 2, None], 9])
    # num = -2

    path_sums: list[int] = []
    for node in tree:
        path_sums.extend(tree_path_sums(node))

    print(path_sums.count(num))

Example #20

File: p107_sum_within_bounds.py Project: tusharsadhwani/daily_byte

def main() -> None:
    """Main function"""
    tree = build_tree([1, [7, 4, None], [5, 3, 9]])
    low = 3
    high = 5

    total = 0
    for node in tree:
        if low <= node.value <= high:
            total += node.value

    print(total)

Example #21

File: p35_find_the_mode.py Project: tusharsadhwani/daily_byte

def main() -> None:
    """Main function"""
    bst = build_tree([2, 1, 2])
    # bst = build_tree([7, [4, 1, 4], [9, 8, [9, None, 9]]])

    max_count = 0
    max_value = -1
    last_value: Optional[int] = None
    count = 0
    for node in bst:
        if last_value != node.value:
            last_value = node.value
            count = 1
        else:
            count += 1

        if count > max_count:
            max_count = count
            max_value = node.value

    print(max_value)

Example #22

def main() -> None:
    """Main function"""
    tree = build_tree([1, [5, 1, None], [4, 9, 9]])

    print(max_sum(tree))

Example #23

File: p49_sum_left_leaves.py Project: tusharsadhwani/daily_byte

def main() -> None:
    """Main function"""
    tree = build_tree([5, 2, [12, 3, 8]])
    # tree = build_tree([2, [4, 3, 9], 2])

    print(sum_left_leaves(tree))

Example #24

File: p46_validate_tree.py Project: tusharsadhwani/daily_byte

def main() -> None:
    """Main function"""
    tree = build_tree([1, 2, 3])
    # tree = build_tree([2, 1, 3])

    print(validate_bst(tree))

Example #25

def main() -> None:
    """Main function"""
    tree = build_tree([3, [1, 2, 8], [7, 4, 6]])
    dead = [7, 8]

    print([node.value for node in trim_tree(tree, dead)])

Example #26

File: p85_iterative_indorder_traversal.py Project: tusharsadhwani/daily_byte

def main() -> None:
    """Main function"""
    tree = build_tree([2, 1, 3])
    # tree = build_tree([2, [1, 4, 8], 7])

    print(iterative_inorder_traversal(tree))

Example #27

File: p42_gather_columns.py Project: tusharsadhwani/daily_byte

def main() -> None:
    """Main function"""
    tree = build_tree([8, 2, [29, 3, 9]])
    # tree = build_tree([100, [53, 32, 3], [78, 9, 20]])

    print(gather_columns(tree))

Example #28

def main() -> None:
    """Main function"""
    tree = build_tree([9, 1, 2])
    tree = build_tree([5, 1, [29, 4, 13]])

    print(calculate_depth(tree))

Example #29

def main() -> None:
    """Main function"""
    tree = build_tree([1, [6, 1, 5], 8])
    print([mean(level) for level in level_order_traversal(tree)])