GeeksforGeeks App
Open App
Browser
Continue

# 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 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 ``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 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 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 q = ``new` `Queue();` `    ``// 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

 ``

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``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

 ``

Output:

`7 4 3 1 6 5 12 8 10`

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

My Personal Notes arrow_drop_up