HackerRank Day 23 Solution In Python: BST Level Order Traversal

Today we will see the HackerRank Day 23 Solution in Python. The problem is BST Level Order Traversal, part of 30 Days of code on HackerRank. Let’s get started!

Day 23: BST Level Order Traversal Problem statement

We are given a pointer, which points to the root of a binary search tree. Our task is to complete the levelOrder function provided so that it prints the level-order traversal of the binary search tree. A level-order traversal, known as a breadth-first search, visits each level of a tree’s nodes from left to right, top to bottom.

Sample Input

Sample Output

3 2 5 1 4 7

Explanation: We traverse each level of the tree from the root downward, and we process the nodes at each level from left to right. The resulting level-order traversal is 3->2->5->1->4->7, and we print these data values as a single line of space-separated integers.

You can solve the problem h ere.

HackerRank Day 23 Solution in Python

import sys

class Node:
    def __init__(self,data):
        self.right=self.left=None
        self.data = data
        
class Solution:
    def insert(self,root,data):
        if root==None:
            return Node(data)
        else:
            if data<=root.data:
                cur=self.insert(root.left,data)
                root.left=cur
            else:
                cur=self.insert(root.right,data)
                root.right=cur
        return root

    #Function to perform Level order traversal
    def levelOrder(self,root):
        #Create list to store the iterations and result
        current_level = [root]
        next_level = []
        result = []
        
        #Iterate through the tree
        while current_level:
            next_level = []
            
            #Iterate through the level
            for node in current_level:
                result.append(str(node.data))
                if node.left:
                    next_level.append(node.left)
                if node.right:
                    next_level.append(node.right)
            
            #Increment to the next level
            current_level = next_level
        
        #Print the result of level order traversal
        print(" ".join(result))
        
T=int(input())
myTree=Solution()
root=None
for i in range(T):
    data=int(input())
    root=myTree.insert(root,data)
myTree.levelOrder(root)

Code Explanation

First, we create a levelOrder function to perform Level order traversal
Create a list current_level to start with the root, next_level to store the subsequent iterations, and result to keep the level order traversal output
Iterate through the tree through each level. Add the node data to the result if present, then check for the left and right nodes and add them to the list
Increment the current level to the next level and repeat the steps
Finally, we print the result list

Best 100+ Python Projects with source code

Also Read: