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);
}
} |
Python3
# Python program to construct BST # using level order traversal # Node class of a binary tree class Node:
def __init__( self ,data):
self .data = data
self .left = None
self .right = None
# Class formed to store the # details of the ancestors class NodeDetails:
def __init__( self ,node, min , Max ):
self .node = node
self . min = min
self . max = Max
# Function for the preorder traversal def preorder(root):
if (root = = None ):
return
print (root.data ,end = " " )
# Traversing left child
preorder(root.left)
# Traversing right child
preorder(root.right)
# Function to construct BST def constructBST(arr, n):
# Creating root of the BST
root = Node(arr[ 0 ])
q = []
# Node details for the root of the BST
q.append(NodeDetails(root, - 1000000000 ,
1000000000 ))
# Index variable to access array elements
i = 1
# Until queue is not empty
while ( len (q) ! = 0 ):
# Extracting NodeDetails of a node
# from the queue
temp = q[ 0 ]
q = q[ 1 :]
c = temp.node
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 and Min < arr[i] and arr[i] < c.data):
# Make this node as left child of
# 'temp.node'
c.left = Node(arr[i])
i + = 1
# Create new node details and add
# it to queue
q.append(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 and c.data < arr[i] and arr[i] < Max ):
# Make this node as right child of
# 'temp.node'
c.right = Node(arr[i])
i + = 1
# Create new node details and add it to
# queue
q.append(NodeDetails(c.right,
c.data, Max ))
# Root of the required BST
return root
# Driver code n = 9
arr = [ 7 , 4 , 12 , 3 , 6 , 8 , 1 , 5 , 10 ]
# Function Call root = constructBST(arr, n)
preorder(root) # This code is contributed by shinjanpatra |
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 |
Javascript
<script> // Javascript program to construct BST // using level order traversal // Node class of a binary tree class Node { constructor(data)
{
this .data = data;
this .left = null ;
this .right = null ;
}
} // Class formed to store the // details of the ancestors class NodeDetails { constructor(node, min, max)
{
this .node = node;
this .min = min;
this .max = max;
}
} // Function for the preorder traversal function preorder(root)
{ if (root == null )
return ;
document.write(root.data + " " );
// Traversing left child
preorder(root.left);
// Traversing right child
preorder(root.right);
} // Function to construct BST function constructBST(arr, n)
{ // Creating root of the BST
var root = new Node(arr[0])
var q = [];
// Node details for the root of the BST
q.push( new NodeDetails(root, -1000000000,
1000000000));
// Index variable to access array elements
var i = 1;
// Until queue is not empty
while (q.length != 0)
{
// Extracting NodeDetails of a node
// from the queue
var temp = q.shift();
var c = temp.node;
var 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.push( 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.push( new NodeDetails(c.right,
c.data, max));
}
}
// Root of the required BST
return root;
} // Driver code var n = 9;
var arr = [ 7, 4, 12, 3, 6, 8, 1, 5, 10 ];
// Function Call var root = constructBST(arr, n);
preorder(root); // This code is contributed by noob2000 </script> |
Output:
7 4 3 1 6 5 12 8 10
Time Complexity: O(N)
Auxiliary Space: O(N) due to queue data structure
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 construct a 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 construct a 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 construct a 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 |
Javascript
<script> // JavaScript implementation to construct a BST // from its level order traversal // Node of a BST class Node { constructor(data)
{
this .data = data;
this .left = null ;
this .right = null ;
}
} let root; // Function to print the inorder traversal function preorderTraversal(root)
{ if (root == null )
return ;
document.write(root.data, " " );
preorderTraversal(root.left);
preorderTraversal(root.right);
} // Function to get a new Node* function getNode(data)
{ // Allocate memory
let node = new Node(data);
return node;
} // Function to construct a BST from // its level order traversal function LevelOrder(root,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;
} function constructBst(arr, n)
{ if (n == 0)
return null ;
root = null ;
for (let i = 0; i < n; i++)
root = LevelOrder(root, arr[i]);
return root;
} // Driver code let arr = [ 7, 4, 12, 3, 6, 8, 1, 5, 10 ]; let n = arr.length; // Function Call root = constructBst(arr, n); preorderTraversal(root); // code is contributed by shinjanpatra </script> |
Output:
7 4 3 1 6 5 12 8 10
Time Complexity for Python Code O(N log(N))