Skip to content
Related Articles

Related Articles

Construct BST from its given level order traversal | Set-2
  • Difficulty Level : Hard
  • Last Updated : 07 Dec, 2020

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 the right child of ‘temp.ptr’ or not.
  • End the loop when the queue becomes empty.

Below is the implementation of the above approach:

C++




// 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 };
     
    // Function Call
    Node* root = constructBst(arr, n);
 
    preorderTraversal(root);
 
    return 0;
}

Java




// JAVA program to construct BST
// using level order traversal
import java.io.*;
import java.util.*;
 
// Node class of a binary tree
class Node {
    int data;
    Node left, right;
 
    public Node(int data)
    {
        this.data = data;
        left = right = null;
    }
}
 
// Class formed to store the
// details of the ancestors
class NodeDetails {
    Node node;
    int min, max;
    public NodeDetails(Node node, int min, int max)
    {
        this.node = node;
        this.min = min;
        this.max = max;
    }
}
 
class GFG {
 
    // Function for the preorder traversal
    public static void preorder(Node root)
    {
        if (root == null)
            return;
        System.out.print(root.data + " ");
 
        // traversing left child
        preorder(root.left);
 
        // traversing right child
        preorder(root.right);
    }
     
    // Function to construct BST
    public static Node constructBST(int[] arr, int n)
    {
        // creating root of the BST
        Node root = new Node(arr[0]);
        Queue<NodeDetails> q = new LinkedList<>();
 
        // node details for the root of the BST
        q.add(new NodeDetails(root, Integer.MIN_VALUE,
                              Integer.MAX_VALUE));
 
        // index variable to access array elements
        int i = 1;
 
        // until queue is not empty
        while (!q.isEmpty()) {
 
            // extracting NodeDetails of a node from the
            // queue
            NodeDetails temp = q.poll();
            Node c = temp.node;
            int min = temp.min, max = temp.max;
 
            // checking whether there are more elements in
            // the array and arr[i] can be left child of
            // 'temp.node' or not
            if (i < n && min < arr[i] && arr[i] < c.data) {
 
                // make this node as left child of
                // 'temp.node'
                c.left = new Node(arr[i]);
                i++;
 
                // create new node details and add it to
                // queue
                q.add(new NodeDetails(c.left, min, c.data));
            }
 
            // checking whether there are more elements in
            // the array and arr[i] can be right child of
            // 'temp.node' or not
            if (i < n && c.data < arr[i] && arr[i] < max) {
 
                // make this node as right child of
                // 'temp.node'
                c.right = new Node(arr[i]);
                i++;
 
                // create new node details and add it to
                // queue
                q.add(
                    new NodeDetails(c.right, c.data, max));
            }
        }
 
        // root of the required BST
        return root;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int n = 9;
        int[] arr = { 7, 4, 12, 3, 6, 8, 1, 5, 10 };
 
        // Function Call
        Node root = constructBST(arr, n);
        preorder(root);
    }
}

C#




// C# program to construct BST
// using level order traversal
using System;
using System.Collections.Generic;
 
// Node class of a binary tree
public class Node
{
    public int data;
    public Node left, right;
 
    public Node(int data)
    {
        this.data = data;
        left = right = null;
    }
}
 
// Class formed to store the
// details of the ancestors
public class NodeDetails
{
    public Node node;
    public int min, max;
     
    public NodeDetails(Node node, int min,
                                  int max)
    {
        this.node = node;
        this.min = min;
        this.max = max;
    }
}
 
class GFG{
 
// Function for the preorder traversal
public static void preorder(Node root)
{
    if (root == null)
        return;
         
    Console.Write(root.data + " ");
 
    // Traversing left child
    preorder(root.left);
 
    // Traversing right child
    preorder(root.right);
}
 
// Function to construct BST
public static Node constructBST(int[] arr, int n)
{
     
    // Creating root of the BST
    Node root = new Node(arr[0]);
    Queue<NodeDetails> q = new Queue<NodeDetails>();
 
    // Node details for the root of the BST
    q.Enqueue(new NodeDetails(root, int.MinValue,
                                    int.MaxValue));
 
    // Index variable to access array elements
    int i = 1;
 
    // Until queue is not empty
    while (q.Count != 0)
    {
         
        // Extracting NodeDetails of a node
        // from the queue
        NodeDetails temp = q.Dequeue();
        Node c = temp.node;
        int min = temp.min, max = temp.max;
 
        // Checking whether there are more
        // elements in the array and arr[i]
        // can be left child of
        // 'temp.node' or not
        if (i < n && min < arr[i] &&
                  arr[i] < c.data)
        {
             
            // Make this node as left child of
            // 'temp.node'
            c.left = new Node(arr[i]);
            i++;
 
            // Create new node details and add
            // it to queue
            q.Enqueue(new NodeDetails(c.left, min,
                                      c.data));
        }
 
        // Checking whether there are more elements in
        // the array and arr[i] can be right child of
        // 'temp.node' or not
        if (i < n && c.data < arr[i] && arr[i] < max)
        {
             
            // Make this node as right child of
            // 'temp.node'
            c.right = new Node(arr[i]);
            i++;
 
            // Create new node details and add it to
            // queue
            q.Enqueue( new NodeDetails(c.right,
                                       c.data, max));
        }
    }
 
    // Root of the required BST
    return root;
}
 
// Driver code
public static void Main(String[] args)
{
    int n = 9;
    int[] arr = { 7, 4, 12, 3, 6, 8, 1, 5, 10 };
 
    // Function Call
    Node root = constructBST(arr, n);
     
    preorder(root);
}
}
 
// This code is contributed by Princi Singh
Output: 



7 4 3 1 6 5 12 8 10

 

Time Complexity: O(N) 
 

Recursive Approach:

Below is the recursion methods to construct BST. 

C++




// C++ implementation to construct a BST
// from its level order traversal
#include<bits/stdc++.h>
using namespace std;
 
// Node* of a BST
struct Node
{
    int data;
    Node* left;
    Node* right;
      
    Node(int data)
    {
        this->data = data;
        this->left  = NULL;
        this->right = NULL;
    }
};
  
Node* root;
  
// Function to print the inorder traversal
void  preorderTraversal(Node* root)
{
    if (root == NULL)
        return;
          
    cout<<(root->data) << " ";
      
    preorderTraversal(root->left);
    preorderTraversal(root->right);
}
  
// Function to get a new Node*
Node* getNode(int data)
{
      
    // Allocate memory
    Node* node = new Node(data);
  
    return node;
}
  
// Function to cona BST from
// its level order traversal
Node* LevelOrder(Node* root, int data)
{
    if (root == NULL)
    {
        root = getNode(data);
        return root;
    }
  
    if (data <= root->data)
        root->left = LevelOrder(root->left, data);
    else
        root->right = LevelOrder(root->right, data);
    return root;
}
  
Node* constructBst(int arr[], int n)
{
    if (n == 0)
        return NULL;
          
     root = NULL;
  
    for(int i = 0; i < n; i++)
        root = LevelOrder(root, arr[i]);
  
    return root;
}
  
// Driver code
int main()
{
 
    int arr[] = { 7, 4, 12, 3, 6,
                  8, 1, 5, 10 };
                    
    int n = sizeof(arr)/sizeof(arr[0]);
  
    // Function Call
    root = constructBst(arr, n);
    preorderTraversal(root);
    return 0;
}
 
// This code is contributed by pratham76

Java




// Java implementation to construct a BST
// from its level order traversal
class GFG{
 
// Node of a BST
static class Node
{
    int data;
    Node left;
    Node right;
     
    Node(int data)
    {
        this.data = data;
        this.left  = null;
        this.right = null;
    }
};
 
static Node root;
 
// Function to print the inorder traversal
static void  preorderTraversal(Node root)
{
    if (root == null)
        return;
         
    System.out.print(root.data + " ");
     
    preorderTraversal(root.left);
    preorderTraversal(root.right);
}
 
// Function to get a new node
static Node getNode(int data)
{
     
    // Allocate memory
    Node node = new Node(data);
 
    return node;
}
 
// Function to cona BST from
// its level order traversal
static Node LevelOrder(Node root, int data)
{
    if (root == null)
    {
        root = getNode(data);
        return root;
    }
 
    if (data <= root.data)
        root.left = LevelOrder(root.left, data);
    else
        root.right = LevelOrder(root.right, data);
    return root;
}
 
static Node constructBst(int []arr, int n)
{
    if (n == 0)
        return null;
         
     root = null;
 
    for(int i = 0; i < n; i++)
        root = LevelOrder(root, arr[i]);
 
    return root;
}
 
// Driver code
public static void main(String[] args)
{
    int[] arr = { 7, 4, 12, 3, 6,
                  8, 1, 5, 10 };
                   
    int n = arr.length;
 
    // Function Call
    root = constructBst(arr, n);
    preorderTraversal(root);
}
}
 
// This code is contributed by shikhasingrajput

Python3




# Python3 implementation to construct a BST
# from its level order traversal
import math
 
# node of a BST
class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
 
# function to print the inorder traversal
def preorderTraversal(root):
    if (root == None):
        return None
    print(root.data, end=" ")
    preorderTraversal(root.left)
    preorderTraversal(root.right)
 
# function to get a new node
def getNode(data):
 
    # Allocate memory
    newNode = Node(data)
 
    # put in the data
    newNode.data = data
    newNode.left = None
    newNode.right = None
    return newNode
 
# function to construct a BST from
# its level order traversal
def LevelOrder(root, data):
    if(root == None):
        root = getNode(data)
        return root
 
    if(data <= root.data):
        root.left = LevelOrder(root.left, data)
    else:
        root.right = LevelOrder(root.right, data)
    return root
 
 
def constructBst(arr, n):
    if(n == 0):
        return None
    root = None
 
    for i in range(0, n):
        root = LevelOrder(root, arr[i])
 
    return root
 
 
# Driver code
if __name__ == '__main__':
 
    arr = [7, 4, 12, 3, 6, 8, 1, 5, 10]
    n = len(arr)
 
    # Function Call
    root = constructBst(arr, n)
    root = preorderTraversal(root)
 
# This code is contributed by Srathore

C#




// C# implementation to construct a BST
// from its level order traversal
using System;
 
class GFG{
 
// Node of a BST
public class Node
{
    public int data;
    public Node left;
    public Node right;
     
    public Node(int data)
    {
        this.data = data;
        this.left  = null;
        this.right = null;
    }
};
 
static Node root;
 
// Function to print the inorder traversal
static void  preorderTraversal(Node root)
{
    if (root == null)
        return;
         
    Console.Write(root.data + " ");
     
    preorderTraversal(root.left);
    preorderTraversal(root.right);
}
 
// Function to get a new node
static Node getNode(int data)
{
     
    // Allocate memory
    Node node = new Node(data);
 
    return node;
}
 
// Function to cona BST from
// its level order traversal
static Node LevelOrder(Node root, int data)
{
    if (root == null)
    {
        root = getNode(data);
        return root;
    }
 
    if (data <= root.data)
        root.left = LevelOrder(root.left, data);
    else
        root.right = LevelOrder(root.right, data);
    return root;
}
 
static Node constructBst(int []arr, int n)
{
    if (n == 0)
        return null;
         
     root = null;
 
    for(int i = 0; i < n; i++)
        root = LevelOrder(root, arr[i]);
 
    return root;
}
 
// Driver code
public static void Main(string[] args)
{
    int[] arr = { 7, 4, 12, 3, 6,
                  8, 1, 5, 10 };
                   
    int n = arr.Length;
 
    // Function Call
    root = constructBst(arr, n);
    preorderTraversal(root);
}
}
 
// This code is contributed by rutvik_56
Output: 
7 4 3 1 6 5 12 8 10

 

Time Complexity for Python Code O(N log(N))
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :