Construct BST from its given level order traversal - GeeksforGeeks

07 Jul, 2021
Construct the BST (Binary Search Tree) from its given level order traversal.Examples:  
Input : arr[] = {7, 4, 12, 3, 6, 8, 1, 5, 10}
Output : BST: 
        7        
       / \       
      4   12      
     / \  /     
    3  6 8    
   /  /   \
  1   5   10
 
The idea is to use the Recursion:- We know that the first element will always be the root of tree and second element will be the left child and third element will be the right child (if fall in the range), and so on for all the remaining elements.1) First pick the first element of the array and make it root. 2) Pick the second element, if it’s value is smaller than root node value make it left child, 3) Else make it right child 4) Now recursively call the step (2) and step (3) to make a BST from its level Order Traversal.Below is the implementation of above approach:  
C++
Java
Python3
C#
Javascript
// C++ implementation to construct a BST// from its level order traversal#include <bits/stdc++.h> using namespace std;  // node of a BSTstruct Node{    int data;    Node *left, *right;};  // function to get a new nodeNode* getNode(int data){    // Allocate memory    Node *newNode =        (Node*)malloc(sizeof(Node));         // put in the data       newNode->data = data;    newNode->left = newNode->right = NULL;       return newNode;}  // function to construct a BST from// its level order traversalNode *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;    Node *root =NULL;     for(int i=0;i<n;i++)    root = LevelOrder(root , arr[i]);         return root;} // function to print the inorder traversalvoid inorderTraversal(Node* root){    if (!root)        return;         inorderTraversal(root->left);    cout << root->data << " ";    inorderTraversal(root->right);   }  // Driver program to test aboveint main(){    int arr[] = {7, 4, 12, 3, 6, 8, 1, 5, 10};    int n = sizeof(arr) / sizeof(arr[0]);         Node *root = constructBst(arr, n);         cout << "Inorder Traversal: ";    inorderTraversal(root);    return 0;   }
// Java implementation to construct a BST// from its level order traversalclass GFG{ // node of a BSTstatic class Node{    int data;    Node left, right;};  // function to get a new nodestatic Node getNode(int data){    // Allocate memory    Node newNode = new Node();         // put in the data    newNode.data = data;    newNode.left = newNode.right = null;    return newNode;}  // function to construct a BST from// its level order traversalstatic 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;    Node root = null;     for(int i = 0; i < n; i++)    root = LevelOrder(root , arr[i]);         return root;} // function to print the inorder traversalstatic void inorderTraversal(Node root){    if (root == null)        return;         inorderTraversal(root.left);    System.out.print( root.data + " ");    inorderTraversal(root.right);}  // Driver codepublic static void main(String args[]){    int arr[] = {7, 4, 12, 3, 6, 8, 1, 5, 10};    int n = arr.length;         Node root = constructBst(arr, n);         System.out.print( "Inorder Traversal: ");    inorderTraversal(root);}} // This code is contributed by Arnab Kundu
# Python implementation to construct a BST# from its level order traversalimport math # node of a BSTclass Node:    def __init__(self,data):        self.data = data        self.left = None        self.right = None # function to get a new nodedef 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 traversaldef 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 # function to print the inorder traversaldef inorderTraversal( root):    if (root == None):        return None         inorderTraversal(root.left)    print(root.data,end = " ")    inorderTraversal(root.right) # Driver programif __name__=='__main__':     arr = [7, 4, 12, 3, 6, 8, 1, 5, 10]    n = len(arr)         root = constructBst(arr, n)         print("Inorder Traversal: ", end = "")    root = inorderTraversal(root)         # This code is contributed by Srathore
// C# implementation to construct a BST// from its level order traversalusing System; class GFG{ // node of a BSTpublic class Node{    public int data;    public Node left, right;}; // function to get a new nodestatic Node getNode(int data){    // Allocate memory    Node newNode = new Node();         // put in the data    newNode.data = data;    newNode.left = newNode.right = null;    return newNode;} // function to construct a BST from// its level order traversalstatic 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;    Node root = null;     for(int i = 0; i < n; i++)    root = LevelOrder(root, arr[i]);         return root;} // function to print the inorder traversalstatic void inorderTraversal(Node root){    if (root == null)        return;         inorderTraversal(root.left);    Console.Write( root.data + " ");    inorderTraversal(root.right);} // Driver codepublic static void Main(String []args){    int []arr = {7, 4, 12, 3,                 6, 8, 1, 5, 10};    int n = arr.Length;         Node root = constructBst(arr, n);         Console.Write("Inorder Traversal: ");    inorderTraversal(root);}} // This code is contributed by Rajput-Ji
<script>       // JavaScript implementation to construct a BST      // from its level order traversal      // node of a BST      class Node {        constructor() {          this.data = 0;          this.left = null;          this.right = null;        }      }       // function to get a new node      function getNode(data) {        // Allocate memory        var newNode = new Node();         // put in the data        newNode.data = data;        newNode.left = newNode.right = null;        return newNode;      }       // 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;        var root = null;         for (var i = 0; i < n; i++)        root = LevelOrder(root, arr[i]);         return root;      }       // function to print the inorder traversal      function inorderTraversal(root) {        if (root == null) return;         inorderTraversal(root.left);        document.write(root.data + " ");        inorderTraversal(root.right);      }       // Driver code      var arr = [7, 4, 12, 3, 6, 8, 1, 5, 10];      var n = arr.length;       var root = constructBst(arr, n);       document.write("Inorder Traversal: ");      inorderTraversal(root);       </script>
Output:  
Inorder Traversal: 1 3 4 5 6 7 8 10 12
Time Complexity : O(n2) This is because the above program is like we are inserting n nodes in a bst which takes O(n2) time in the worst case.This article is contributed by Nishant Balayan. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
its_strange
andrew1234
Rajput-Ji
sapnasingh4991
shobhitgupta907
rdtank
cpp-queue
Traversal
tree-level-order
Binary Search Tree
Tree
Traversal
Binary Search Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Inorder Successor in Binary Search Tree
Red-Black Tree | Set 2 (Insert)
Find the node with minimum value in a Binary Search Tree
Optimal Binary Search Tree | DP-24
Overview of Data Structures | Set 2 (Binary Tree, BST, Heap and Hash)
Tree Traversals (Inorder, Preorder and Postorder)
Binary Tree | Set 1 (Introduction)
Level Order Binary Tree Traversal
Inorder Tree Traversal without Recursion
Binary Tree | Set 3 (Types of Binary Tree)