def insert(self, root: Node, data: int) -> Node:
if not root:
return Node(data)
if data < root.data:
root.left = self.insert(root.left, data)
elif data > root.data:
root.right = self.insert(root.right, data)
return root
def deserialize_helper(self, q: queue):
val = q.get()
if val == 'X':
return None
root = Node(int(val))
root.left = self.deserialize_helper(q)
root.right = self.deserialize_helper(q)
return root
def show_mirror_tree(self, root: Node) -> Node:
if root is None:
return root
# temp = root
self.show_mirror_tree(root.left)
self.show_mirror_tree(root.right)
temp = root.left
root.left = root.right
root.right = temp
def main():
node = Node(1)
node.left = Node(2)
node.right = Node(3)
node.left.left = Node(4)
node.left.right = Node(5)
bst = BinarySearchTree()
print("Pre order traversal of binary tree is")
bst.pre_order_traversal(node)
print("In order traversal of binary tree is")
bst.level_order_traversal(node)
print("Post order traversal of binary tree is")
bst.post_order_traversal(node)
def main():
node = Node(50)
bst = BinarySearchTree()
largest_node = LargestNode()
c = [0]
k = 4
bst.insert(node, 30)
bst.insert(node, 20)
bst.insert(node, 40)
bst.insert(node, 70)
bst.insert(node, 60)
bst.insert(node, 80)
largest_node.kth_largest_node(node, k, c)
def main():
all_nodes = AllNodesAtKDistance()
node = Node(6)
bt = BinaryTree()
bt.insert(node, Node(4))
x = Node(2)
y = Node(7)
bt.insert(node, x)
bt.insert(node, y)
bt.insert(node, Node(9))
bt.insert(node, Node(10))
print(all_nodes.k_th_distance_node(node, x, 2))
return root
def get_child_to_parent_mapping(self, relation: dict, node: Node) -> dict:
if node is None:
return
if node.left is not None:
relation[node.left] = node
self.get_child_to_parent_mapping(relation, node.left)
if node.right is not None:
relation[node.right] = node
self.get_child_to_parent_mapping(relation, node.right)
return relation
if __name__ == '__main__':
node = Node(7)
bst = BinarySearchTree()
bst.insert(node, 4)
bst.insert(node, 11)
bst.insert(node, 2)
bst.insert(node, 6)
bst.insert(node, 9)
# bst.insert(node, 1)
# bst.insert(node, 0)
# token = bst.serialize(node)
# print(token)
# bst.deserialize(token)
# bst.print_tree(node)
relation = {}
relation = bst.get_child_to_parent_mapping(relation, node)
for child in relation:
while len(queue) != 0:
current_node = queue.pop(0)
print(current_node.data)
if current_node.left is not None:
queue.append(current_node.left)
if current_node.right is not None:
queue.append(current_node.right)
def show_mirror_tree(self, root: Node) -> Node:
if root is None:
return root
# temp = root
self.show_mirror_tree(root.left)
self.show_mirror_tree(root.right)
temp = root.left
root.left = root.right
root.right = temp
if __name__ == '__main__':
node = Node(10)
bst = BinarySearchTree()
bst.insert(node, 5)
bst.insert(node, 23)
bst.insert(node, 9)
bst.insert(node, 16)
bst.insert(node, 0)
level_order_traversal = LevelOrderTraversal()
level_order_traversal.show_mirror_tree(node)
level_order_traversal.level_order(node, [])
class LowestCommonAncestor(object):
def get_lca(self, root: Node, x: Node, y: Node) -> Node:
if root is None:
return
if root.data == x.data or y.data:
return root
left_subtree = self.get_lca(root.left, x, y)
right_subtree = self.get_lca(root.right, x, y)
if left_subtree is None:
return right_subtree
if right_subtree is None:
return left_subtree
return root
if __name__ == '__main__':
node = Node(6)
bt = BinaryTree()
bt.insert(node, Node(4))
x = Node(2)
y = Node(7)
bt.insert(node, x)
bt.insert(node, y)
bt.insert(node, Node(9))
bt.insert(node, Node(10))
lca = LowestCommonAncestor()
lca_node = lca.get_lca(node, x, y)
print(lca_node.data)
def get_diagonal_sum(self, root: Node) -> dict:
answer = {}
self.calculate_sum(root, 0, answer)
return answer
def print_the_tree(self, root: Node):
if root is None:
return
print(root.data)
self.print_the_tree(root.left)
self.print_the_tree(root.right)
if __name__ == '__main__':
node = Node(1)
bt = BinaryTree()
bt.insert(node, Node(2))
bt.insert(node, Node(3))
bt.insert(node, Node(9))
bt.insert(node, Node(6))
bt.insert(node, Node(4))
bt.insert(node, Node(5))
bt.insert(node, Node(12))
bt.insert(node, Node(11))
bt.insert(node, Node(10))
ds = DiagonalSum()
bst_level_order = LevelOrderTraversal()
bst_level_order.level_order(node, [])
print(ds.get_diagonal_sum(node).values())