GFG App
Open App
Browser
Continue

# Construct a tree from Inorder and Level order traversals | Set 2

Given inorder and level-order traversals of a Binary Tree, construct the Binary Tree. Following is an example to illustrate the problem.

Examples:

```Input: Two arrays that represent Inorder
and level order traversals of a
Binary Tree
in[]    = {4, 8, 10, 12, 14, 20, 22};
level[] = {20, 8, 22, 4, 12, 10, 14};

Output: Construct the tree represented
by the two arrays.
For the above two arrays, the
constructed tree is shown.```

We have discussed a solution in below post that works in O(N^3)
Construct a tree from Inorder and Level order traversals | Set 1

Approach: Following algorithm uses O(N^2) time complexity to solve the above problem using the unordered_set data structure in c++ (basically making a hash-table) to put the values of left subtree of the current root and later and we will check in O(1) complexity to find if the current levelOrder node is part of left subtree or not.
If it is the part of left subtree then add in one lLevel array for left otherwise add it to rLevel array for right subtree.

Below is the implementation with the above idea :

## C++

 `/* program to construct tree using inorder ` `   ``and levelorder traversals */` `#include ` `using` `namespace` `std;`   `/* A binary tree node */` `struct` `Node` `{` `    ``int` `key;` `    ``struct` `Node* left, *right;` `};`   `Node* makeNode(``int` `data){` `    ``Node* newNode = ``new` `Node();` `    ``newNode->key = data;` `    ``newNode->right = newNode->right = NULL;` `    ``return` `newNode;` `}`   `// Function to build tree from given ` `// levelorder and inorder` `Node* buildTree(``int` `inorder[], ``int` `levelOrder[],` `                ``int` `iStart, ``int` `iEnd, ``int` `n)` `{` `    ``if` `(n <= 0) ` `          ``return` `NULL;`   `    ``// First node of level order is root` `    ``Node* root = makeNode(levelOrder[0]);`   `    ``// Search root in inorder` `    ``int` `index = -1;` `    ``for` `(``int` `i=iStart; i<=iEnd; i++){` `        ``if` `(levelOrder[0] == inorder[i]){` `            ``index = i;` `            ``break``;` `        ``}` `    ``}`   `    ``// Insert all left nodes in hash table` `    ``unordered_set<``int``> s;` `    ``for` `(``int` `i=iStart;ileft = buildTree(inorder, lLevel, ` `                 ``iStart, index-1, index-iStart);` `    ``root->right = buildTree(inorder, rLevel, ` `                  ``index+1, iEnd, iEnd-index);` `    ``return` `root;`   `}`   `/* Utility function to print inorder ` `traversal of binary tree */` `void` `printInorder(Node* node)` `{` `    ``if` `(node == NULL)` `       ``return``;` `    ``printInorder(node->left);` `    ``cout << node->key << ``" "``;` `    ``printInorder(node->right);` `}`   `// Driver Code ` `int` `main()` `{` `    ``int` `in[] = {4, 8, 10, 12, 14, 20, 22};` `    ``int` `level[] = {20, 8, 22, 4, 12, 10, 14};` `    ``int` `n = ``sizeof``(in)/``sizeof``(in[0]);` `    ``Node *root = buildTree(in, level, 0,` `                           ``n - 1, n);`   `    ``/* Let us test the built tree by ` `     ``printing Inorder traversal */` `    ``cout << ``"Inorder traversal of the "` `            ``"constructed tree is \n"``;` `    ``printInorder(root);`   `    ``return` `0;` `}`

## Java

 `/*` ` ``* program to construct tree using inorder ` ` ``* and levelorder traversals` ` ``*/` `import` `java.util.HashSet;` `class` `GFG` `{`   `  ``/* A binary tree node */` `  ``static` `class` `Node {` `    ``int` `key;` `    ``Node left, right;` `  ``};`   `  ``static` `Node makeNode(``int` `data) {` `    ``Node newNode = ``new` `Node();` `    ``newNode.key = data;` `    ``newNode.right = newNode.right = ``null``;` `    ``return` `newNode;` `  ``}`   `  ``// Function to build tree from given` `  ``// levelorder and inorder` `  ``static` `Node buildTree(``int` `inorder[], ``int` `levelOrder[], ``int` `iStart, ``int` `iEnd, ``int` `n) {` `    ``if` `(n <= ``0``)` `      ``return` `null``;`   `    ``// First node of level order is root` `    ``Node root = makeNode(levelOrder[``0``]);`   `    ``// Search root in inorder` `    ``int` `index = -``1``;` `    ``for` `(``int` `i = iStart; i <= iEnd; i++) {` `      ``if` `(levelOrder[``0``] == inorder[i]) {` `        ``index = i;` `        ``break``;` `      ``}` `    ``}`   `    ``// Insert all left nodes in hash table` `    ``HashSet s = ``new` `HashSet<>();` `    ``for` `(``int` `i = iStart; i < index; i++)` `      ``s.add(inorder[i]);`   `    ``// Separate level order traversals` `    ``// of left and right subtrees.` `    ``int``[] lLevel = ``new` `int``[s.size()]; ``// Left` `    ``int``[] rLevel = ``new` `int``[iEnd - iStart - s.size()]; ``// Right` `    ``int` `li = ``0``, ri = ``0``;` `    ``for` `(``int` `i = ``1``; i < n; i++) {` `      ``if` `(s.contains(levelOrder[i]))` `        ``lLevel[li++] = levelOrder[i];` `      ``else` `        ``rLevel[ri++] = levelOrder[i];` `    ``}`   `    ``// Recursively build left and right` `    ``// subtrees and return root.` `    ``root.left = buildTree(inorder, lLevel, iStart, index - ``1``, index - iStart);` `    ``root.right = buildTree(inorder, rLevel, index + ``1``, iEnd, iEnd - index);` `    ``return` `root;`   `  ``}`   `  ``/*` `     ``* Utility function to print inorder ` `     ``* traversal of binary tree` `     ``*/` `  ``static` `void` `printInorder(Node node) {` `    ``if` `(node == ``null``)` `      ``return``;` `    ``printInorder(node.left);` `    ``System.out.print(node.key + ``" "``);` `    ``printInorder(node.right);` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args) {`   `    ``int` `in[] = { ``4``, ``8``, ``10``, ``12``, ``14``, ``20``, ``22` `};` `    ``int` `level[] = { ``20``, ``8``, ``22``, ``4``, ``12``, ``10``, ``14` `};` `    ``int` `n = in.length;` `    ``Node root = buildTree(in, level, ``0``, n - ``1``, n);`   `    ``/*` `         ``* Let us test the built tree by ` `         ``* printing Inorder traversal` `         ``*/` `    ``System.out.println(``"Inorder traversal of the constructed tree is "``);` `    ``printInorder(root);`   `  ``}` `}`   `// This code is contributed by sanjeev2552`

## Python3

 `# program to construct tree using inorder and levelorder traversals` `import` `collections`   `class` `Node:` `    ``# A binary tree node` `    ``def` `__init__(``self``, key):` `        ``self``.key ``=` `key` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `def` `makeNode(data):` `    ``newNode ``=` `Node(data)` `    ``return` `newNode`   `# Function to build tree from given levelorder and inorder` `def` `buildTree(inorder, levelOrder, iStart, iEnd):` `    ``n ``=` `len``(levelOrder)` `    ``if` `n <``=` `0``:` `        ``return` `None`   `    ``# First node of level order is root` `    ``root ``=` `makeNode(levelOrder[``0``])`   `    ``# Search root in inorder` `    ``index ``=` `-``1` `    ``for` `i ``in` `range``(iStart, iEnd``+``1``):` `        ``if` `levelOrder[``0``] ``=``=` `inorder[i]:` `            ``index ``=` `i` `            ``break`   `    ``# Insert all left nodes in hash table` `    ``s ``=` `set``()` `    ``for` `i ``in` `range``(iStart, index):` `        ``s.add(inorder[i])`   `    ``# Separate level order traversals of left and right subtrees.` `    ``lLevel ``=` `[]` `    ``rLevel ``=` `[]` `    ``li ``=` `0` `    ``ri ``=` `0` `    ``for` `i ``in` `range``(``1``, n):` `        ``if` `levelOrder[i] ``in` `s:` `            ``lLevel.append(levelOrder[i])` `            ``li ``+``=` `1` `        ``else``:` `            ``rLevel.append(levelOrder[i])` `            ``ri ``+``=` `1`   `    ``# Recursively build left and right subtrees and return root` `    ``root.left ``=` `buildTree(inorder, lLevel, iStart, index``-``1``)` `    ``root.right ``=` `buildTree(inorder, rLevel, index``+``1``, iEnd)` `    ``return` `root`   `# Utility function to print inorder traversal of binary tree` `def` `printInorder(node):` `    ``if` `node ``is` `None``:` `        ``return` `    ``printInorder(node.left)` `    ``print``(node.key, end``=``' '``)` `    ``printInorder(node.right)`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``inOrder ``=` `[``4``, ``8``, ``10``, ``12``, ``14``, ``20``, ``22``]` `    ``levelOrder ``=` `[``20``, ``8``, ``22``, ``4``, ``12``, ``10``, ``14``]` `    ``n ``=` `len``(inOrder)` `    ``root ``=` `buildTree(inOrder, levelOrder, ``0``, n``-``1``)`   `    ``# Let us test the built tree by printing Inorder traversal` `    ``print``(``"Inorder traversal of the constructed tree is "``)` `    ``printInorder(root)`

## C#

 `/*` ` ``* program to construct tree using inorder` ` ``* and levelorder traversals` ` ``*/` `using` `System;` `using` `System.Collections;` `using` `System.Collections.Generic;`   `class` `GFG {`   `  ``/* A binary tree node */` `  ``public` `class` `Node {` `    ``public` `int` `key;` `    ``public` `Node left, right;` `  ``};`   `  ``static` `Node makeNode(``int` `data)` `  ``{` `    ``Node newNode = ``new` `Node();` `    ``newNode.key = data;` `    ``newNode.right = newNode.right = ``null``;` `    ``return` `newNode;` `  ``}`   `  ``// Function to build tree from given` `  ``// levelorder and inorder` `  ``static` `Node buildTree(``int``[] inorder, ``int``[] levelOrder,` `                        ``int` `iStart, ``int` `iEnd, ``int` `n)` `  ``{` `    ``if` `(n <= 0)` `      ``return` `null``;`   `    ``// First node of level order is root` `    ``Node root = makeNode(levelOrder[0]);`   `    ``// Search root in inorder` `    ``int` `index = -1;` `    ``for` `(``int` `i = iStart; i <= iEnd; i++) {` `      ``if` `(levelOrder[0] == inorder[i]) {` `        ``index = i;` `        ``break``;` `      ``}` `    ``}`   `    ``// Insert all left nodes in hash table` `    ``HashSet<``int``> s = ``new` `HashSet<``int``>();` `    ``for` `(``int` `i = iStart; i < index; i++)` `      ``s.Add(inorder[i]);`   `    ``// Separate level order traversals` `    ``// of left and right subtrees.` `    ``int``[] lLevel = ``new` `int``[s.Count]; ``// Left` `    ``int``[] rLevel` `      ``= ``new` `int``[iEnd - iStart - s.Count]; ``// Right` `    ``int` `li = 0, ri = 0;` `    ``for` `(``int` `i = 1; i < n; i++) {` `      ``if` `(s.Contains(levelOrder[i]))` `        ``lLevel[li++] = levelOrder[i];` `      ``else` `        ``rLevel[ri++] = levelOrder[i];` `    ``}`   `    ``// Recursively build left and right` `    ``// subtrees and return root.` `    ``root.left = buildTree(inorder, lLevel, iStart,` `                          ``index - 1, index - iStart);` `    ``root.right = buildTree(inorder, rLevel, index + 1,` `                           ``iEnd, iEnd - index);` `    ``return` `root;` `  ``}`   `  ``/*` `     ``* Utility function to print inorder` `     ``* traversal of binary tree` `     ``*/` `  ``static` `void` `printInorder(Node node)` `  ``{` `    ``if` `(node == ``null``)` `      ``return``;` `    ``printInorder(node.left);` `    ``Console.Write(node.key + ``" "``);` `    ``printInorder(node.right);` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{`   `    ``int``[] inorder` `      ``= ``new` `int``[] { 4, 8, 10, 12, 14, 20, 22 };` `    ``int``[] level` `      ``= ``new` `int``[] { 20, 8, 22, 4, 12, 10, 14 };` `    ``int` `n = inorder.Length;` `    ``Node root = buildTree(inorder, level, 0, n - 1, n);`   `    ``/*` `         ``* Let us test the built tree by` `         ``* printing Inorder traversal` `         ``*/` `    ``Console.WriteLine(` `      ``"Inorder traversal of the constructed tree is "``);` `    ``printInorder(root);` `  ``}` `}`   `// This code is contributed by Karandeep1234`

## Javascript

 ``

Output

```Inorder traversal of the constructed tree is
4 8 10 12 14 20 22 ```

Time Complexity: O(N^2)

Optimization: Without separate level order traversal arrays of left and right subtrees.

Approach: Using Hashing.

Use a HashMap to store the indices of level order traversal. In the range of start & end from inorder, search the element with the least index from the level order map. Create left and right subtrees recursively.

```index -> the least index
for left subtree: start to index-1
for right subtree: index+1 to end```

Implementation:

## C++

 `// C++ Program to implement above approach` `#include ` `using` `namespace` `std;`   `// Node Structure` `struct` `Node {` `    ``int` `data;` `    ``Node* left;` `    ``Node* right;` `    ``Node(``int` `data)` `    ``{` `        ``this``->data = data;` `        ``this``->left = NULL;` `        ``this``->right = NULL;` `    ``}` `};`   `map<``int``, ``int``> mp;`   `// function to construct hashmap` `void` `constructMap(``int` `level[], ``int` `n)` `{` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``mp[level[i]] = i;` `    ``}` `}`   `// function to construct binary tree from inorder and` `// levelorder traversal` `Node* construct(``int` `in[], ``int` `start, ``int` `end)` `{` `    ``// if start is greater than end return null` `    ``if` `(start > end)` `        ``return` `NULL;`   `    ``int` `min_index = start;`   `    ``// In the range of start & end from inorder, search the` `    ``// element with least index from level order map` `    ``for` `(``int` `i = start + 1; i <= end; i++) {` `        ``int` `temp = in[i];` `        ``// if current element from inorder have least index` `        ``// in levelorder map, update min_index` `        ``if` `(mp[in[min_index]] > mp[temp])` `            ``min_index = i;` `    ``}`   `    ``// create a node with current element` `    ``Node* root = ``new` `Node(in[min_index]);`   `    ``// if start is equal to end, then return root` `    ``if` `(start == end)` `        ``return` `root;`   `    ``// construct left and right subtrees` `    ``root->left = construct(in, start, min_index - 1);` `    ``root->right = construct(in, min_index + 1, end);` `    ``return` `root;` `}`   `// Function to print inorder traversal` `void` `printInorder(Node* node)` `{` `    ``if` `(node == NULL)` `        ``return``;` `    ``printInorder(node->left);` `    ``cout << node->data << ``" "``;` `    ``printInorder(node->right);` `}`   `// Driver Function` `int` `main()` `{` `    ``int` `in[] = { 4, 8, 10, 12, 14, 20, 22 };` `    ``int` `level[] = { 20, 8, 22, 4, 12, 10, 14 };` `    ``int` `size = ``sizeof``(level) / ``sizeof``(level[0]);` `    ``// function calls` `    ``constructMap(level, size);` `    ``int` `n = mp.size();` `    ``Node* root = construct(in, 0, n - 1);` `    ``printInorder(root);` `    ``return` `0;` `}` `// This code is contributed by Yash` `// Agarwal(yashagarwal2852002)`

## Java

 `import` `java.util.HashMap;`   `//class Node` `class` `Node{` `    ``int` `data;` `    ``Node left,right;` `    ``Node(``int` `data){` `        ``this``.data = data;` `        ``left = right = ``null``;` `    ``}` `}`   `public` `class` `ConstructTree {` `    `  `    ``//hashmap to store the indices of levelorder array` `    ``HashMap map = ``new` `HashMap<>();` `    `  `    ``//function to construct hashmap` `    ``void` `constructMap(``int` `level[]) {` `        ``for``(``int` `i=``0``;i end)` `            ``return` `null``;` `        `  `        ``int` `min_index = start;` `        `  `        ``//In the range of start & end from inorder, search the element` `        ``//with least index from level order map` `        ``for``(``int` `i=start+``1``;i<=end;i++) {` `            ``int` `temp = in[i];` `            ``//if current element from inorder have least index in ` `            ``//levelorder map, update min_index` `            ``if``(map.get(in[min_index]) > map.get(temp))` `                ``min_index = i;` `        ``}` `        `  `        ``//create a node with current element` `        ``Node root = ``new` `Node(in[min_index]);` `        `  `        ``//if start is equal to end, then return root` `        ``if``(start == end)` `            ``return` `root;` `        `  `        ``//construct left and right subtrees` `        ``root.left = construct(in,start,min_index-``1``);` `        ``root.right = construct(in,min_index+``1``,end);` `        `  `        ``return` `root;` `    ``}` `    `  `    ``//function to print inorder ` `    ``void` `printInorder(Node node) {` `        ``if` `(node == ``null``)` `          ``return``;` `        ``printInorder(node.left);` `        ``System.out.print(node.data + ``" "``);` `        ``printInorder(node.right);` `      ``}` `    `  `    ``//Driver function` `    ``public` `static` `void` `main(String[] args) {` `        ``ConstructTree tree = ``new` `ConstructTree();` `        `  `        ``int` `in[]    = {``4``, ``8``, ``10``, ``12``, ``14``, ``20``, ``22``};` `        ``int` `level[] = {``20``, ``8``, ``22``, ``4``, ``12``, ``10``, ``14``};` `        `  `        ``//function calls` `        ``tree.constructMap(level);` `        ``int` `n = level.length;` `        ``Node root = tree.construct(in, ``0``, n-``1``);` `        ``tree.printInorder(root);` `    ``}` `}`   `//This method is contributed by Likhita AVL`

## Python3

 `from` `typing ``import` `List` `from` `collections ``import` `deque`   `# class Node` `class` `Node:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `class` `ConstructTree:` `    `  `    ``def` `__init__(``self``):` `        ``# dictionary to store the indices of levelorder array` `        ``self``.``map` `=` `{}`   `    ``# function to construct hashmap` `    ``def` `constructMap(``self``, level: ``List``[``int``]) ``-``> ``None``:` `        ``for` `i ``in` `range``(``len``(level)):` `            ``self``.``map``[level[i]] ``=` `i` `    `  `    ``# function to construct binary tree from inorder and levelorder` `    ``def` `construct(``self``, in_: ``List``[``int``], start: ``int``, end: ``int``) ``-``> Node:` `        ``# if start is greater than end return None` `        ``if` `start > end:` `            ``return` `None` `        `  `        ``min_index ``=` `start` `        `  `        ``# In the range of start & end from inorder, search the element` `        ``# with least index from level order map` `        ``for` `i ``in` `range``(start ``+` `1``, end ``+` `1``):` `            ``temp ``=` `in_[i]` `            ``# if current element from inorder have least index in ` `            ``# levelorder map, update min_index` `            ``if` `self``.``map``[in_[min_index]] > ``self``.``map``[temp]:` `                ``min_index ``=` `i` `        `  `        ``# create a node with current element` `        ``root ``=` `Node(in_[min_index])` `        `  `        ``# if start is equal to end, then return root` `        ``if` `start ``=``=` `end:` `            ``return` `root` `        `  `        ``# construct left and right subtrees` `        ``root.left ``=` `self``.construct(in_, start, min_index ``-` `1``)` `        ``root.right ``=` `self``.construct(in_, min_index ``+` `1``, end)` `        `  `        ``return` `root` `    `  `    ``# function to print inorder ` `    ``def` `printInorder(``self``, node: Node) ``-``> ``None``:` `        ``if` `node ``is` `None``:` `            ``return` `        ``self``.printInorder(node.left)` `        ``print``(node.data, end``=``" "``)` `        ``self``.printInorder(node.right)` `    `  `    ``# Driver function` `    ``def` `main(``self``) ``-``> ``None``:` `        ``tree ``=` `ConstructTree()` `        `  `        ``in_ ``=` `[``4``, ``8``, ``10``, ``12``, ``14``, ``20``, ``22``]` `        ``level ``=` `[``20``, ``8``, ``22``, ``4``, ``12``, ``10``, ``14``]` `        `  `        ``# function calls` `        ``tree.constructMap(level)` `        ``n ``=` `len``(level)` `        ``root ``=` `tree.construct(in_, ``0``, n``-``1``)` `        ``tree.printInorder(root)`   `if` `__name__ ``=``=` `"__main__"``:` `    ``t ``=` `ConstructTree()` `    ``t.main()`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `Node` `{` `    ``public` `int` `data;` `    ``public` `Node left, right;`   `    ``public` `Node(``int` `data)` `    ``{` `        ``this``.data = data;` `        ``left = right = ``null``;` `    ``}` `}`   `public` `class` `BinaryTree` `{` `    ``public` `static` `Dictionary<``int``, ``int``> mp = ``new` `Dictionary<``int``, ``int``>();`   `    ``// function to construct hashmap` `    ``public` `static` `void` `constructMap(``int``[] level, ``int` `n)` `    ``{` `        ``for` `(``int` `i = 0; i < n; i++)` `        ``{` `            ``mp[level[i]] = i;` `        ``}` `    ``}`   `    ``// function to construct binary tree from inorder and` `    ``// levelorder traversal` `    ``public` `static` `Node construct(``int``[] inOrder, ``int` `start, ``int` `end)` `    ``{` `        ``// if start is greater than end return null` `        ``if` `(start > end)` `            ``return` `null``;`   `        ``int` `min_index = start;`   `        ``// In the range of start & end from inorder, search the` `        ``// element with least index from level order map` `        ``for` `(``int` `i = start + 1; i <= end; i++)` `        ``{` `            ``int` `temp = inOrder[i];` `            ``// if current element from inorder have least index` `            ``// in levelorder map, update min_index` `            ``if` `(mp[inOrder[min_index]] > mp[temp])` `                ``min_index = i;` `        ``}`   `        ``// create a node with current element` `        ``Node root = ``new` `Node(inOrder[min_index]);`   `        ``// if start is equal to end, then return root` `        ``if` `(start == end)` `            ``return` `root;`   `        ``// construct left and right subtrees` `        ``root.left = construct(inOrder, start, min_index - 1);` `        ``root.right = construct(inOrder, min_index + 1, end);` `        ``return` `root;` `    ``}`   `    ``// Function to print inorder traversal` `    ``public` `static` `void` `printInorder(Node node)` `    ``{` `        ``if` `(node == ``null``)` `            ``return``;` `        ``printInorder(node.left);` `        ``Console.Write(node.data + ``" "``);` `        ``printInorder(node.right);` `    ``}`   `    ``// Driver Function` `    ``public` `static` `void` `Main()` `    ``{` `        ``int``[] inOrder = { 4, 8, 10, 12, 14, 20, 22 };` `        ``int``[] levelOrder = { 20, 8, 22, 4, 12, 10, 14 };` `        ``int` `n = levelOrder.Length;`   `        ``// function calls` `        ``constructMap(levelOrder, n);` `        ``Node root = construct(inOrder, 0, n - 1);` `        ``printInorder(root);` `    ``}` `}`

## Javascript

 `// JavaScript program to implement above approach` `// Node structure` `class Node{` `    ``constructor(data){` `        ``this``.data = data;` `        ``this``.left = ``null``;` `        ``this``.right = ``null``;` `    ``}` `}`   `let mp = ``new` `Map();`   `// function to construct hashmap` `function` `constructMap(level, n){` `    ``for``(let i = 0; i end) ``return` `null``;` `    `  `    ``let min_index = start;` `    `  `    ``// In the range of start and end from inorder, search the ` `    ``// element with least index from level order map` `    ``for``(let i = start+1; i<=end; i++){` `        ``let temp = IN[i];` `        `  `        ``// if current element from inorder have least index` `        ``// in levelroder map, update min_index` `        ``if``(mp.get(IN[min_index]) > mp.get(temp)){` `            ``min_index = i;` `        ``}` `    ``}` `    `  `    ``// create a node with current element` `    ``let root = ``new` `Node(IN[min_index]);` `    `  `    ``// if start is equal to end, then return root` `    ``if``(start == end)` `        ``return` `root;` `    `  `    ``// construct left and right subtrees` `    ``root.left = construct(IN, start, min_index-1);` `    ``root.right = construct(IN, min_index+1, end);` `    ``return` `root;` `}`   `// function to print inorder traversal` `function` `printInorder(node){` `    ``if``(node == ``null``)` `        ``return``;` `    ``printInorder(node.left);` `    ``console.log(node.data + ``" "``);` `    ``printInorder(node.right);` `}`   `// driver function` `let IN = [4, 8, 10, 12, 14, 20, 22];` `let level = [20, 8, 22, 4, 12, 10, 14];` `let size = level.length;`   `// function calls` `constructMap(level, size);` `let n = mp.size;` `let root = construct(IN, 0, n-1);` `printInorder(root);`   `// this code is contributed by Kirit Agarwal(kirtiagarwal23121999)`

Output

`4 8 10 12 14 20 22 `

Time Complexity: O(n^2).

Another approach using queue.

## C++

 `//{ Driver Code Starts` `#include `   `using` `namespace` `std;` `struct` `Node {` `    ``int` `key;` `    ``struct` `Node* left;` `    ``struct` `Node* right;`   `    ``Node(``int` `x)` `    ``{` `        ``key = x;` `        ``left = NULL;` `        ``right = NULL;` `    ``}` `};`   `Node* buildTree(``int` `inorder[], ``int` `levelOrder[], ``int` `iStart,` `                ``int` `iEnd, ``int` `n);` `void` `printInorder(Node* node)` `{` `    ``if` `(node == NULL)` `        ``return``;` `    ``printInorder(node->left);` `    ``cout << node->key << ``" "``;` `    ``printInorder(node->right);` `}` `int` `main()` `{`   `    ``int` `n = 7;` `    ``int` `in[] = { 4, 8, 10, 12, 14, 20, 22 };` `    ``int` `level[] = { 20, 8, 22, 4, 12, 10, 14 };` `    ``Node* root = NULL;` `    ``root = buildTree(in, level, 0, n - 1, n);` `    ``printInorder(root);` `    ``cout << endl;`   `    ``return` `0;` `}` `// } Driver Code Ends`   `/*Complete the function below` `Node is as follows:` `struct Node` `{` `    ``int key;` `    ``struct Node* left, *right;` `};` `*/` `Node* buildTree(``int` `inorder[], ``int` `levelOrder[], ``int` `iStart,` `                ``int` `iEnd, ``int` `n)` `{` `    ``queue > > q;` `    ``unordered_map<``int``, ``int``> mp;` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``mp[inorder[i]] = i;` `    ``int` `idx = 0;` `    ``Node* root = ``new` `Node(levelOrder[idx++]);` `    ``q.push({ root, { 0, n - 1 } });` `    ``while` `(!q.empty()) {` `        ``int` `m = q.size();` `        ``for` `(``int` `i = 0; i < m; i++) {` `            ``auto` `p = q.front();` `            ``q.pop();` `            ``int` `leftEnd = mp[p.first->key] - 1;` `            ``int` `rightStart = mp[p.first->key] + 1;` `            ``// check if nodes to added into the left part of` `            ``// q.front()` `            ``if` `(p.second.first <= leftEnd) {` `                ``p.first->left = ``new` `Node(levelOrder[idx++]);` `                ``q.push({ p.first->left,` `                         ``{ p.second.first, leftEnd } });` `            ``}` `            ``// check if nodes to added into the right part` `            ``// of q.front()` `            ``if` `(rightStart <= p.second.second) {` `                ``p.first->right` `                    ``= ``new` `Node(levelOrder[idx++]);` `                ``q.push({ p.first->right,` `                         ``{ rightStart, p.second.second } });` `            ``}` `        ``}` `    ``}` `    ``return` `root;` `}`

## Python3

 `class` `Node:` `    ``def` `__init__(``self``, x):` `        ``self``.key ``=` `x` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `def` `buildTree(inorder, levelOrder, iStart, iEnd, n):` `    ``q ``=` `[]` `    ``mp ``=` `{}` `    ``for` `i ``in` `range``(n):` `        ``mp[inorder[i]] ``=` `i` `    ``idx ``=` `0` `    ``root ``=` `Node(levelOrder[idx])` `    ``idx ``+``=` `1` `    ``q.append((root, [``0``, n ``-` `1``]))` `    ``while` `len``(q) !``=` `0``:` `        ``m ``=` `len``(q)` `        ``for` `i ``in` `range``(m):` `            ``node, [leftStart, rightEnd] ``=` `q.pop(``0``)` `            ``leftEnd ``=` `mp[node.key] ``-` `1` `            ``rightStart ``=` `mp[node.key] ``+` `1` `            ``if` `leftStart <``=` `leftEnd:` `                ``node.left ``=` `Node(levelOrder[idx])` `                ``idx ``+``=` `1` `                ``q.append((node.left, [leftStart, leftEnd]))` `            ``if` `rightStart <``=` `rightEnd:` `                ``node.right ``=` `Node(levelOrder[idx])` `                ``idx ``+``=` `1` `                ``q.append((node.right, [rightStart, rightEnd]))` `    ``return` `root`   `def` `printInorder(node):` `    ``if` `node ``is` `None``:` `        ``return` `    ``printInorder(node.left)` `    ``print``(node.key, end``=``" "``)` `    ``printInorder(node.right)`   `n ``=` `7` `inOrder ``=` `[``4``, ``8``, ``10``, ``12``, ``14``, ``20``, ``22``]` `levelOrder ``=` `[``20``, ``8``, ``22``, ``4``, ``12``, ``10``, ``14``]` `root ``=` `None` `root ``=` `buildTree(inOrder, levelOrder, ``0``, n ``-` `1``, n)` `printInorder(root)`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `Node {` `    ``public` `int` `key;` `    ``public` `Node left;` `    ``public` `Node right;`   `    ``public` `Node(``int` `x)` `    ``{` `        ``key = x;` `        ``left = ``null``;` `        ``right = ``null``;` `    ``}` `};`   `public` `class` `Gfg` `{` `    ``public` `static` `Node buildTree(``int``[] inorder, ``int``[] levelOrder, ``int` `iStart,` `                ``int` `iEnd, ``int` `n) {` `        ``Queue>> q = ``new` `Queue>>();` `        ``Dictionary<``int``, ``int``> mp = ``new` `Dictionary<``int``, ``int``>();` `        ``for` `(``int` `i = 0; i < n; i++)` `            ``mp[inorder[i]] = i;` `        ``int` `idx = 0;` `        ``Node root = ``new` `Node(levelOrder[idx++]);` `        ``q.Enqueue(Tuple.Create(root, Tuple.Create(0, n - 1)));` `        ``while` `(q.Count > 0) {` `            ``int` `m = q.Count;` `            ``for` `(``int` `i = 0; i < m; i++) {` `                ``var` `p = q.Dequeue();` `                ``int` `leftEnd = mp[p.Item1.key] - 1;` `                ``int` `rightStart = mp[p.Item1.key] + 1;` `                ``// check if nodes to added into the left part of` `                ``// q.front()` `                ``if` `(p.Item2.Item1 <= leftEnd) {` `                    ``p.Item1.left = ``new` `Node(levelOrder[idx++]);` `                    ``q.Enqueue(Tuple.Create(p.Item1.left,` `                         ``Tuple.Create(p.Item2.Item1, leftEnd)));` `                ``}` `                ``// check if nodes to added into the right part` `                ``// of q.front()` `                ``if` `(rightStart <= p.Item2.Item2) {` `                    ``p.Item1.right` `                        ``= ``new` `Node(levelOrder[idx++]);` `                    ``q.Enqueue(Tuple.Create(p.Item1.right,` `                         ``Tuple.Create(rightStart, p.Item2.Item2)));` `                ``}` `            ``}` `        ``}` `        ``return` `root;` `    ``}`   `    ``public` `static` `void` `printInorder(Node node)` `    ``{` `        ``if` `(node == ``null``)` `            ``return``;` `        ``printInorder(node.left);` `        ``Console.Write(node.key + ``" "``);` `        ``printInorder(node.right);` `    ``}`   `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `n = 7;` `        ``int``[] inOrder = { 4, 8, 10, 12, 14, 20, 22 };` `        ``int``[] levelOrder = { 20, 8, 22, 4, 12, 10, 14 };` `        ``Node root = buildTree(inOrder, levelOrder, 0, n - 1, n);` `        ``printInorder(root);` `        ``Console.WriteLine();` `    ``}` `}`

## Javascript

 `// THIS CODE IS CONTRIBUTED BY CHANDAN AGARWAL` `class Node {` `  ``constructor(x) {` `    ``this``.key = x;` `    ``this``.left = ``null``;` `    ``this``.right = ``null``;` `  ``}` `}`   `function` `buildTree(inorder, levelOrder, iStart, iEnd, n) {` `  ``const q = [];` `  ``const mp = ``new` `Map();` `  ``for` `(let i = 0; i < n; i++) {` `    ``mp.set(inorder[i], i);` `  ``}` `  ``let idx = 0;` `  ``const root = ``new` `Node(levelOrder[idx++]);` `  ``q.push([root, [0, n - 1]]);` `  ``while` `(q.length !== 0) {` `    ``const m = q.length;` `    ``for` `(let i = 0; i < m; i++) {` `      ``const [node, [leftStart, rightEnd]] = q.shift();` `      ``const leftEnd = mp.get(node.key) - 1;` `      ``const rightStart = mp.get(node.key) + 1;` `      ``if` `(leftStart <= leftEnd) {` `        ``node.left = ``new` `Node(levelOrder[idx++]);` `        ``q.push([node.left, [leftStart, leftEnd]]);` `      ``}` `      ``if` `(rightStart <= rightEnd) {` `        ``node.right = ``new` `Node(levelOrder[idx++]);` `        ``q.push([node.right, [rightStart, rightEnd]]);` `      ``}` `    ``}` `  ``}` `  ``return` `root;` `}`   `function` `printInorder(node) {` `  ``if` `(node === ``null``) ``return``;` `  ``printInorder(node.left);` `  ``console.log(node.key + ``" "``);` `  ``printInorder(node.right);` `}`   `const n = 7;` `const inOrder = [4, 8, 10, 12, 14, 20, 22];` `const levelOrder = [20, 8, 22, 4, 12, 10, 14];` `let root = ``null``;` `root = buildTree(inOrder, levelOrder, 0, n - 1, n);` `printInorder(root);` `console.log(``""``);`

## Java

 `// Java Program for the above approach`   `import` `java.util.*;`   `class` `Node {` `    ``public` `int` `key;` `    ``public` `Node left;` `    ``public` `Node right;`   `    ``public` `Node(``int` `x)` `    ``{` `        ``key = x;` `        ``left = ``null``;` `        ``right = ``null``;` `    ``}` `}`   `// Pair Class of Java` `class` `Pair {` `    ``private` `final` `K key;` `    ``private` `final` `V value;`   `    ``public` `Pair(K key, V value) {` `        ``this``.key = key;` `        ``this``.value = value;` `    ``}`   `    ``public` `K getKey() {` `        ``return` `key;` `    ``}`   `    ``public` `V getValue() {` `        ``return` `value;` `    ``}` `}` `class` `Gfg {` `    ``public` `static` `Node buildTree(``int``[] inorder, ``int``[] levelOrder, ``int` `iStart,` `                ``int` `iEnd, ``int` `n) {` `        ``Queue>> q = ``new` `LinkedList<>();` `        ``HashMap mp = ``new` `HashMap<>();` `        ``for` `(``int` `i = ``0``; i < n; i++)` `            ``mp.put(inorder[i], i);` `        ``int` `idx = ``0``;` `        ``Node root = ``new` `Node(levelOrder[idx++]);` `        ``q.add(``new` `Pair<>(root, ``new` `Pair<>(``0``, n - ``1``)));` `        ``while` `(!q.isEmpty()) {` `            ``int` `m = q.size();` `            ``for` `(``int` `i = ``0``; i < m; i++) {` `                ``var p = q.poll();` `                ``int` `leftEnd = mp.get(p.getKey().key) - ``1``;` `                ``int` `rightStart = mp.get(p.getKey().key) + ``1``;` `                ``// check if nodes to added into the left part of` `                ``// q.front()` `                ``if` `(p.getValue().getKey() <= leftEnd) {` `                    ``p.getKey().left = ``new` `Node(levelOrder[idx++]);` `                    ``q.add(``new` `Pair<>(p.getKey().left,` `                         ``new` `Pair<>(p.getValue().getKey(), leftEnd)));` `                ``}` `                ``// check if nodes to added into the right part` `                ``// of q.front()` `                ``if` `(rightStart <= p.getValue().getValue()) {` `                    ``p.getKey().right` `                        ``= ``new` `Node(levelOrder[idx++]);` `                    ``q.add(``new` `Pair<>(p.getKey().right,` `                         ``new` `Pair<>(rightStart, p.getValue().getValue())));` `                ``}` `            ``}` `        ``}` `        ``return` `root;` `    ``}`   `    ``public` `static` `void` `printInorder(Node node)` `    ``{` `        ``if` `(node == ``null``)` `            ``return``;` `        ``printInorder(node.left);` `        ``System.out.print(node.key + ``" "``);` `        ``printInorder(node.right);` `    ``}` `    `  `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `n = ``7``;` `        ``int``[] inOrder = { ``4``, ``8``, ``10``, ``12``, ``14``, ``20``, ``22` `};` `        ``int``[] levelOrder = { ``20``, ``8``, ``22``, ``4``, ``12``, ``10``, ``14` `};` `        ``Node root = buildTree(inOrder, levelOrder, ``0``, n - ``1``, n);` `        ``printInorder(root);` `        ``System.out.println();` `    ``}` `}`   `// This code is contributed by codebraxnzt`

Output

`4 8 10 12 14 20 22 `

Time complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up