# 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))