Day 23 BST Level-Order Traversal Hackerrank Solution in C++

Problem:- Day 23 BST Level-Order Traversal hackerRank or Hackerrank: Day 23: BST Level-Order Traversal or binary search tree insertion hackerrank solution or Day 23 BST(binary search tree) Level order traversal hackerrank solution or hackerrank Day 23 BST(binary search tree) Level order traversal solution or hackerrank solution Day 23 BST(binary search tree) Level order traversal solution or hackerrank Day 23 BST Level order traversal solution or hackerrank solution BST Level order traversal solution or hackerrank solution binary search tree Level order traversal solution or (bst) binary search tree Level order traversal solution or hackerrank binary search tree Level order traversal solution.

Problem Statement: BST Level-Order Traversal Hackerrank

Task: A level-order traversal, also known as a breadth-first search, visits each level of a tree’s nodes from left to right, top to bottom. You are given a pointer root pointing to the root of a binary search tree. Complete the level order function provided in your editor so that it prints the level-order traversal of the binary search tree.

Hint: You’ll find a queue helpful in completing this challenge.

Input Format

  • The locked stub code in your editor reads the following inputs and assembles them into a BST:
  • The first line contains an integer, T (the number of test cases). 
  • The T subsequent lines each contain an integer, data, denoting the value of an element that must be added to the BST.

Output Format

Print the data value of each node in the tree’s level-order traversal as a single line of N space-separated integers.

Sample Input

6
3
5
4
7
2
1

Sample Output

3 2 5 1 4 7

Explanation

The input forms the following binary search tree:

Day 23 BST Level-Order Traversal Hackerrank Solution in C++

image Credit:- HackerRank
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.

Day 23 BST Level-Order Traversal Solution in C++

#include <iostream>
#include <cstddef>
#include <queue>
#include <string>
#include <cstdlib>
using namespace std; 
class Node{
    public:
        int data;
        Node *left,*right;
        Node(int d){
            data=d;
            left=right=NULL;
        }
};
class Solution{
    public:
    Node* insert(Node* root, int data){
            if(root==NULL){
                return new Node(data);
            }
            else{
                Node* cur;
                if(data<=root->data){
                    cur=insert(root->left,data);
                    root->left=cur;
                }
                else{
                   cur=insert(root->right,data);
                   root->right=cur;
                 }           
           return root;
           }
        }
       
     
  void levelOrder(Node * root){
    queue<Node *> q;
    Node* n = root;
   
    while(n != NULL){
        cout << n->data << ' ';
        
        if( n->left  != NULL ) q.push(n->left);
        if( n->right != NULL ) q.push(n->right);
        if( !q.empty() ) {
         n = q.front();
         q.pop();
        } else {
         n = NULL;
        }
    }
}

};//End of Solution
int main(){
    Solution myTree;
    Node* root=NULL;
    int T,data;
    cin>>T;
    while(T-->0){
        cin>>data;
        root= myTree.insert(root,data);
    }
    myTree.levelOrder(root);
    return 0;
}

Output:-

Binary search Tree Level Order Traversal HackerRank Solution Output


You May Also Check

1. Day 24: More Linked Lists

2. Day 25: Running Time and Complexity

3. Day 26: Nested Logic

4. Day 27: Testing

5. Day 28: RegEx, Patterns, and Intro to Databases

Submit this solution:-Click Here

What is a Binary Search Tree(BST)

Binary search trees (BST), sometimes called ordered or sorted binary trees, are a particular type of container: data structures that store “items” (such as numbers, names etc.).


Binary search trees keep their keys in sorted order so that lookup and other operations can use the principle of binary search: when looking for a key in a tree (or a place to insert a new key), they traverse the tree from root to leaf, making comparisons to keys stored in the nodes of the tree and deciding, on the basis of the comparison, to continue searching in the left or right subtrees. On average, this means that each comparison allows the operations to skip about half of the tree so that each lookup, insertion or deletion takes time proportional to the logarithm of the number of items stored in the tree.

Binary Search Tree Time and Space Complexity

Below are the Time and Space Complexity of the Binary Search Tree.

Algorithm Average Case     Worst Case
Space O(n)         O(n)
SearchO(log n)         O(n)
InsertO(log n)         O(n)
DeleteO(log n)         O(n)

Don't Miss Any Future Post!

Subscribe to our mailing list and get interesting stuff and updates to your email inbox.

Thank you for subscribing.

Something went wrong.

Give a Comment

This site uses Akismet to reduce spam. Learn how your comment data is processed.