# breadth first search called in graph algorithms
from data import get_sample_data
def level_order_traversal(root):
queue = []
queue.append(root)
while queue:
root = queue.pop(0)
print(root.data)
if root.left:
queue.append(root.left)
if root.right:
queue.append(root.right)
if __name__ == "__main__":
level_order_traversal(get_sample_data())
from data import get_sample_data
def print_level_order_reverse(root):
q = []
s = []
q.append(root)
while q:
temp = q.pop(0)
s.append(temp.data)
if temp.left:
q.append(temp.left)
if temp.right:
q.append(temp.right)
for i in list(reversed(s)):
print(i)
if __name__ == "__main__":
print_level_order_reverse(get_sample_data())
# preorder traversal without recursion
# while doing preorder without recursion first we process the current node
# we use stack to keep track of current node
# first we process left subtree and then we process right subtree
from data import get_sample_data
def preorder_without_recursion(root):
stack = []
while True:
while root:
# process the current node
print(root.data)
stack.append(root)
# if the left subtree exists push it to the stack
root = root.left
if not stack: # if stack is empty
break
root = stack.pop(-1)
# indicates the completion of left subtree then move to right subtree
root = root.right
if __name__ == "__main__":
preorder_without_recursion(get_sample_data())
# deepest node in tree using level order traversal
from data import get_sample_data
def without_recursion(root):
deepest_node = None
if not root:
return None
queue = []
queue.append(root)
while queue:
deepest_node = queue.pop(0)
if deepest_node.left:
queue.append(deepest_node.left)
if deepest_node.right:
queue.append(deepest_node.right)
return deepest_node.data
if __name__ == "__main__":
print(without_recursion(get_sample_data()))
# do traversal in whichever order you want and rathar than printing value
# calculate max
from data import get_sample_data
def process(root):
stack = []
max_val = -1
while root:
if max_val < root.data:
max_val = root.data
stack.append(root)
root = root.left
if not stack:
break
root = stack.pop(-1)
root = root.right
return max_val
if __name__ == "__main__":
print(process(get_sample_data()))
# find the max value in left subtree and find the max_value in right subtree
# then compare it with root node
# return the largest
from data import get_sample_data
def find_max(root):
if root:
return max(root.data, find_max(root.left), find_max(root.right))
return 0
if __name__ == "__main__":
root = get_sample_data()
print(find_max(root))
from data import get_sample_data
def search_with_recursion(root, search_item):
if not root:
return False
if root.data == search_item:
return True
temp = search_with_recursion(root.left, search_item)
if temp:
return True
else:
return search_with_recursion(root.right, search_item)
print(search_with_recursion(get_sample_data(), 1))
# size of binary tree represents number of elements in binary tree
from data import get_sample_data
def size_of_bt_recursivly(root):
if not root:
return 0
return size_of_bt_recursivly(root.left) + 1 + size_of_bt_recursivly(root.right)
def size_of_bt_without_recursion(root):
if not root:
return 0
q = []
count = 0
q.append(root)
while q:
temp = q.pop(0)
count += 1
if temp.left:
q.append(temp.left)
if temp.right:
q.append(temp.right)
return count
if __name__ == "__main__":
print(size_of_bt_recursivly(get_sample_data()))
print(size_of_bt_without_recursion(get_sample_data()))
def p(root):
global stack
while root:
stack.append(root)
root = root.left
while root == None and not is_empty(stack):
root = stack[-1]
if root.right == None or root.right == previous:
print(root.data)
stack.pop(-1)
previous = root
root = None
else:
root = root.right
return root
stack = []
def process_tree(root):
r = p(root)
while stack:
r = p(r)
if __name__ == "__main__":
process_tree(get_sample_data())
root.left = Node(number)
if root.right:
insertion_with_recursion(root.right, number)
else:
root.right = Node(number)
def insertion_without_recursion(root, number):
if not root:
return
q = []
q.append(root)
while root:
root = q.pop(0)
if root.left:
q.append(root.left)
else:
root.left = Node(number)
if root.right:
q.append(root.right)
else:
root.right = Node(number)
if name == "__main__":
insertion_with_recursion(get_sample_data(), 5)
insertion_without_recursion(get_sample_data(), 5)
# perform level order traversal while searching for element
from data import get_sample_data
def search_without_recursion(root, search_item):
queue = []
if not root:
return False
queue.append(root)
while queue:
temp = queue.pop(0)
if temp.data == search_item:
return True
if temp.left:
queue.append(temp.left)
if temp.right:
queue.append(temp.right)
return False
print(search_without_recursion(get_sample_data(), 10))