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: 

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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);
    }
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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
chevron_right

Output: 

7 4 3 1 6 5 12 8 10

 

Time Complexity: O(N) 
 

Recursive Approach:

Below is the recursion methods to construct BST. 

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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
chevron_right

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.





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 :