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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

Below is the implementation of the above approach

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

Output:

```7 4 3 1 6 5 12 8 10
```

Time Complexity O(N)

My Personal Notes arrow_drop_up 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 :

2

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.