Esempio n. 1
0
        return False


if __name__ == "__main__":
    bst = BST()
    bst.insert(50)
    bst.insert(30)
    bst.insert(20)
    bst.insert(40)
    bst.insert(70)
    bst.insert(60)
    bst.insert(80)

    print("Inorder Traversal")
    inorder(bst.root)
    print()

    print("Delete 20")
    bst.delete(20)
    print("Inorder traversal of the modified tree")
    inorder(bst.root)
    print()

    print("Searching")
    print(bst.search(20))
    print(bst.search(30))

    print("Delete 30")
    bst.delete(30)
    print("Inorder traversal of the modified tree")
    if node.left is not None or node.right is not None:
        left_sum = children_sum(node.left)
        right_sum = children_sum(node.right)
        diff = left_sum + right_sum - node.data

        if diff > 0:
            node.data += diff
        elif diff < 0:
            increment_children_data(node, -diff)

    return node.data


if __name__ == "__main__":
    """
             50
          7       2
       3    5   1   30
    """
    root = Node(50)
    root.left = Node(7)
    root.right = Node(2)
    root.left.left = Node(3)
    root.left.right = Node(5)
    root.right.left = Node(1)
    root.right.right = Node(30)
    children_sum(root)
    inorder(root)
    print()
        if not stack:
            return index


def construct_bin_tree(string: str) -> Optional[Node]:
    length = len(string)

    if length == 0:
        return None

    root = Node(string[0])

    if length > 1:
        left_end_index = get_subtree_string(string, 1, length - 1)
        root.left = construct_bin_tree(string[2:left_end_index])

        if left_end_index < length - 2:
            root.right = construct_bin_tree(string[left_end_index + 2:length -
                                                   1])

    return root


if __name__ == "__main__":
    inorder(construct_bin_tree(""))
    print()
    inorder(construct_bin_tree("1(2)(3)"))
    print()
    inorder(construct_bin_tree("4(2(3)(1))(6(5))"))
    print()
Esempio n. 4
0
"""
from typing import Optional

from daily_problems.binary_tree_node import Node
from gfg.trees.tree_traversal import inorder


def prune(node: Optional[Node]) -> Optional[Node]:
    if not node:
        return None

    node.left = prune(node.left)
    node.right = prune(node.right)

    if node.data == 1 or node.left or node.right:
        return node

    return None


if __name__ == "__main__":
    tree = Node(0)
    tree.left = Node(1)
    tree.right = Node(0)
    tree.right.left = Node(1)
    tree.right.left.left = Node(0)
    tree.right.left.right = Node(0)

    tree = prune(tree)
    inorder(tree)