Construct BST from its given level order traversal | Set-2

Construct the BST (Binary Search Tree) from its given level order traversal.

Examples:

Input : {7, 4, 12, 3, 6, 8, 1, 5, 10}
Output : BST: 
        7        
       / \       
      4   12      
     / \  /     
    3  6 8    
   /  /   \
  1   5   10

Approach :
The idea is to make a struct element NodeDetails which contains a pointer to the node , minimum data and maximum data of the ancestor.Now perform the steps as follows:



  • Push the root node to the queue of type NodeDetails.
  • Extract NodeDetails of a node from the queue and compare them with the minimum and maximum values.
  • Check whether there are more elements in the arr[] and arr[i] can be left child of ‘temp.ptr’ or not .
  • Check whether there are more elements in the arr[] and arr[i] can be right child of ‘temp.ptr’ or not .
  • End the loop when the queue becomes empty.

Below is the implementation of the above approach

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to construct BST 
// using level order traversal
#include <bits/stdc++.h>
using namespace std;
  
// Node structure of a binary tree
struct Node {
    int data;
    Node* right;
    Node* left;
  
    Node(int x)
    {
        data = x;
        right = NULL;
        left = NULL;
    }
};
  
// Structure formed to store the
// details of the ancestor
struct NodeDetails {
    Node* ptr;
    int min, max;
};
  
// Function for the preorder traversal 
void preorderTraversal(Node* root)
{
    if (!root)
        return;
    cout << root->data << " ";
  
    // Traversing left child
    preorderTraversal(root->left);
  
    // Traversing right child
    preorderTraversal(root->right);
}
  
// Function to make a new node
// and return its pointer
Node* getNode(int data)
{
    Node* temp = new Node(0);
    temp->data = data;
    temp->left = NULL;
    temp->right = NULL;
    return temp;
}
  
// Function to construct the BST
Node* constructBst(int arr[], int n)
{
    if (n == 0)
        return NULL;
  
    Node* root;
  
    queue<NodeDetails> q;
  
    // index variable to
    // access array elements
    int i = 0;
  
    // Node details for the
    // root of the BST
    NodeDetails newNode;
    newNode.ptr = getNode(arr[i++]);
    newNode.min = INT_MIN;
    newNode.max = INT_MAX;
    q.push(newNode);
  
    // Getting the root of the BST
    root = newNode.ptr;
  
    // Until there are no more
    // elements in arr[]
    while (i != n) {
  
        // Extracting NodeDetails of a
        // node from the queue
        NodeDetails temp = q.front();
        q.pop();
  
        // Check whether there are more elements
        // in the arr[] and arr[i] can be 
        // left child of 'temp.ptr' or not
        if (i < n && (arr[i] < temp.ptr->data 
                        && arr[i] > temp.min)) {
  
            // Create NodeDetails for newNode
            // and add it to the queue
            newNode.ptr = getNode(arr[i++]);
            newNode.min = temp.min;
            newNode.max = temp.ptr->data;
            q.push(newNode);
  
            // Make this 'newNode' as left child
            // of 'temp.ptr'
            temp.ptr->left = newNode.ptr;
        }
  
        // Check whether there are more elements
        // in the arr[] and arr[i] can be 
        // right child of 'temp.ptr' or not
        if (i < n && (arr[i] > temp.ptr->data
                          && arr[i] < temp.max)) {
  
            // Create NodeDetails for newNode
            // and add it to the queue
            newNode.ptr = getNode(arr[i++]);
            newNode.min = temp.ptr->data;
            newNode.max = temp.max;
            q.push(newNode);
  
            // Make this 'newNode' as right 
            // child of 'temp.ptr'
            temp.ptr->right = newNode.ptr;
        }
    }
  
    // Root of the required BST
    return root;
}
  
// Driver code
int main()
{
    int n = 9;
  
    int arr[n] = { 7, 4, 12, 3, 6, 8, 1, 5, 10 };
  
    Node* root = constructBst(arr, n);
  
    preorderTraversal(root);
  
    return 0;
}

chevron_right


Output:

7 4 3 1 6 5 12 8 10

Time Complexity O(N)



My Personal Notes arrow_drop_up

Competitive Programmer, Full Stack Developer, Technical Content Writer, Machine Learner

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.




Article Tags :
Practice Tags :


2


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.