Skip to content
Related Articles
Construct a special tree from given preorder traversal
• Difficulty Level : Hard
• Last Updated : 10 Feb, 2020

Given an array ‘pre[]’ that represents Preorder traversal of a spacial binary tree where every node has either 0 or 2 children. One more array ‘preLN[]’ is given which has only two possible values ‘L’ and ‘N’. The value ‘L’ in ‘preLN[]’ indicates that the corresponding node in Binary Tree is a leaf node and value ‘N’ indicates that the corresponding node is non-leaf node. Write a function to construct the tree from the given two arrays.

Example:

```Input:  pre[] = {10, 30, 20, 5, 15},  preLN[] = {'N', 'N', 'L', 'L', 'L'}
Output: Root of following tree
10
/  \
30   15
/  \
20   5
```

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

The first element in pre[] will always be root. So we can easily figure out root. If left subtree is empty, the right subtree must also be empty and preLN[] entry for root must be ‘L’. We can simply create a node and return it. If left and right subtrees are not empty, then recursively call for left and right subtrees and link the returned nodes to root.

## C++

 `/* A program to construct Binary Tree from preorder traversal */``#include`` ` `/* A binary tree node structure */``struct` `node``{``    ``int` `data;``    ``struct` `node *left;``    ``struct` `node *right;``};`` ` `/* Utility function to create a new Binary Tree node */``struct` `node* newNode (``int` `data)``{``    ``struct` `node *temp = ``new` `struct` `node;``    ``temp->data = data;``    ``temp->left = NULL;``    ``temp->right = NULL;``    ``return` `temp;``}`` ` `/* A recursive function to create a Binary Tree from given pre[]``   ``preLN[] arrays. The function returns root of tree. index_ptr is used``   ``to update index values in recursive calls. index must be initially``   ``passed as 0 */``struct` `node *constructTreeUtil(``int` `pre[], ``char` `preLN[], ``int` `*index_ptr, ``int` `n)``{``    ``int` `index = *index_ptr; ``// store the current value of index in pre[]`` ` `    ``// Base Case: All nodes are constructed``    ``if` `(index == n)``        ``return` `NULL;`` ` `    ``// Allocate memory for this node and increment index for``    ``// subsequent recursive calls``    ``struct` `node *temp = newNode ( pre[index] );``    ``(*index_ptr)++;`` ` `    ``// If this is an internal node, construct left and right subtrees and link the subtrees``    ``if` `(preLN[index] == ``'N'``)``    ``{``      ``temp->left  = constructTreeUtil(pre, preLN, index_ptr, n);``      ``temp->right = constructTreeUtil(pre, preLN, index_ptr, n);``    ``}`` ` `    ``return` `temp;``}`` ` `// A wrapper over constructTreeUtil()``struct` `node *constructTree(``int` `pre[], ``char` `preLN[], ``int` `n)``{``    ``// Initialize index as 0. Value of index is used in recursion to maintain``    ``// the current index in pre[] and preLN[] arrays.``    ``int` `index = 0;`` ` `    ``return` `constructTreeUtil (pre, preLN, &index, n);``}`` ` ` ` `/* This function is used only for testing */``void` `printInorder (``struct` `node* node)``{``    ``if` `(node == NULL)``        ``return``;`` ` `    ``/* first recur on left child */``    ``printInorder (node->left);`` ` `    ``/* then print the data of node */``    ``printf``(``"%d "``, node->data);`` ` `    ``/* now recur on right child */``    ``printInorder (node->right);``}`` ` `/* Driver function to test above functions */``int` `main()``{``    ``struct` `node *root = NULL;`` ` `    ``/* Constructing tree given in the above figure``          ``10``         ``/  \``        ``30   15``       ``/  \``      ``20   5 */``    ``int` `pre[] = {10, 30, 20, 5, 15};``    ``char` `preLN[] = {``'N'``, ``'N'``, ``'L'``, ``'L'``, ``'L'``};``    ``int` `n = ``sizeof``(pre)/``sizeof``(pre);`` ` `    ``// construct the above tree``    ``root = constructTree (pre, preLN, n);`` ` `    ``// Test the constructed tree``    ``printf``(``"Following is Inorder Traversal of the Constructed Binary Tree: \n"``);``    ``printInorder (root);`` ` `    ``return` `0;``}`

## Java

 `// Java program to construct a binary tree from preorder traversal``  ` `// A Binary Tree node``class` `Node ``{``    ``int` `data;``    ``Node left, right;``  ` `    ``Node(``int` `item) ``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}``  ` `class` `Index ``{``    ``int` `index = ``0``;``}``  ` `class` `BinaryTree ``{``    ``Node root;``    ``Index myindex = ``new` `Index();``  ` `    ``/* A recursive function to create a Binary Tree from given pre[]``       ``preLN[] arrays. The function returns root of tree. index_ptr is used``       ``to update index values in recursive calls. index must be initially``       ``passed as 0 */``    ``Node constructTreeUtil(``int` `pre[], ``char` `preLN[], Index index_ptr, ``                                                     ``int` `n, Node temp)``    ``{``        ``// store the current value of index in pre[]``        ``int` `index = index_ptr.index; ``  ` `        ``// Base Case: All nodes are constructed``        ``if` `(index == n)``            ``return` `null``;``  ` `        ``// Allocate memory for this node and increment index for``        ``// subsequent recursive calls``        ``temp = ``new` `Node(pre[index]);``        ``(index_ptr.index)++;``  ` `        ``// If this is an internal node, construct left and right subtrees ``        ``// and link the subtrees``        ``if` `(preLN[index] == ``'N'``) ``        ``{``            ``temp.left = constructTreeUtil(pre, preLN, index_ptr, n, ``                                                               ``temp.left);``            ``temp.right = constructTreeUtil(pre, preLN, index_ptr, n, ``                                                               ``temp.right);``        ``}``  ` `        ``return` `temp;``    ``}``  ` `    ``// A wrapper over constructTreeUtil()``    ``Node constructTree(``int` `pre[], ``char` `preLN[], ``int` `n, Node node) ``    ``{``        ``// Initialize index as 0. Value of index is used in recursion to``        ``// maintain the current index in pre[] and preLN[] arrays.``        ``int` `index = ``0``;``  ` `        ``return` `constructTreeUtil(pre, preLN, myindex, n, node);``    ``}``  ` `    ``/* This function is used only for testing */``    ``void` `printInorder(Node node) ``    ``{``        ``if` `(node == ``null``)``            ``return``;``  ` `        ``/* first recur on left child */``        ``printInorder(node.left);``  ` `        ``/* then print the data of node */``        ``System.out.print(node.data + ``" "``);``  ` `        ``/* now recur on right child */``        ``printInorder(node.right);``    ``}``  ` `    ``// driver function to test the above functions``    ``public` `static` `void` `main(String args[]) ``    ``{``        ``BinaryTree tree = ``new` `BinaryTree();``        ``int` `pre[] = ``new` `int``[]{``10``, ``30``, ``20``, ``5``, ``15``};``        ``char` `preLN[] = ``new` `char``[]{``'N'``, ``'N'``, ``'L'``, ``'L'``, ``'L'``};``        ``int` `n = pre.length;``  ` `        ``// construct the above tree``        ``Node mynode = tree.constructTree(pre, preLN, n, tree.root);``  ` `        ``// Test the constructed tree``        ``System.out.println(``"Following is Inorder Traversal of the"`  `                                      ``+ ``"Constructed Binary Tree: "``);``        ``tree.printInorder(mynode);``    ``}``}``  ` `// This code has been contributed by Mayank Jaiswal`` `

## Python3

 `# A program to construct Binary ``# Tree from preorder traversal `` ` `# Utility function to create a``# new Binary Tree node ``class` `newNode:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data ``        ``self``.left ``=` `None``        ``self``.right ``=` `None`` ` `# A recursive function to create a``# Binary Tree from given pre[] preLN[] ``# arrays. The function returns root of  ``# tree. index_ptr is used to update ``# index values in recursive calls. index ``# must be initially passed as 0 ``def` `constructTreeUtil(pre, preLN, index_ptr, n):``     ` `    ``index ``=` `index_ptr[``0``] ``# store the current value ``                         ``# of index in pre[] `` ` `    ``# Base Case: All nodes are constructed ``    ``if` `index ``=``=` `n: ``        ``return` `None`` ` `    ``# Allocate memory for this node and ``    ``# increment index for subsequent ``    ``# recursive calls ``    ``temp ``=` `newNode(pre[index]) ``    ``index_ptr[``0``] ``+``=` `1`` ` `    ``# If this is an internal node, construct left``    ``# and right subtrees and link the subtrees ``    ``if` `preLN[index] ``=``=` `'N'``:``        ``temp.left ``=` `constructTreeUtil(pre, preLN, ``                                      ``index_ptr, n) ``        ``temp.right ``=` `constructTreeUtil(pre, preLN, ``                                       ``index_ptr, n) `` ` `    ``return` `temp`` ` `# A wrapper over constructTreeUtil() ``def` `constructTree(pre, preLN, n):``     ` `    ``# Initialize index as 0. Value of index is``    ``# used in recursion to maintain the current ``    ``# index in pre[] and preLN[] arrays. ``    ``index ``=` `[``0``]`` ` `    ``return` `constructTreeUtil(pre, preLN, index, n)`` ` `# This function is used only for testing ``def` `printInorder (node):``    ``if` `node ``=``=` `None``:``        ``return`` ` `    ``# first recur on left child``    ``printInorder (node.left) `` ` `    ``# then print the data of node``    ``print``(node.data,end``=``" "``) `` ` `    ``# now recur on right child ``    ``printInorder (node.right)``     ` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``root ``=` `None`` ` `    ``# Constructing tree given in``    ``# the above figure ``    ``#     10 ``    ``#     / \ ``    ``# 30 15 ``    ``# / \ ``    ``# 20 5 ``    ``pre ``=` `[``10``, ``30``, ``20``, ``5``, ``15``]``    ``preLN ``=` `[``'N'``, ``'N'``, ``'L'``, ``'L'``, ``'L'``] ``    ``n ``=` `len``(pre) `` ` `    ``# construct the above tree ``    ``root ``=` `constructTree (pre, preLN, n) `` ` `    ``# Test the constructed tree ``    ``print``(``"Following is Inorder Traversal of"``,``          ``"the Constructed Binary Tree:"``) ``    ``printInorder (root)``     ` `# This code is contributed by PranchalK`

## C#

 `// C# program to construct a binary ``// tree from preorder traversal ``using` `System;`` ` `// A Binary Tree node ``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right;`` ` `    ``public` `Node(``int` `item)``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}`` ` `public` `class` `Index``{``    ``public` `int` `index = 0;``}`` ` `class` `GFG``{``public` `Node root;``public` `Index myindex = ``new` `Index();`` ` `/* A recursive function to create a ``Binary Tree from given pre[] preLN[] arrays. ``The function returns root of tree. index_ptr ``is used to update index values in recursive ``calls. index must be initially passed as 0 */``public` `virtual` `Node constructTreeUtil(``int``[] pre, ``char``[] preLN, ``                                      ``Index index_ptr, ``int` `n,``                                      ``Node temp)``{``    ``// store the current value of index in pre[] ``    ``int` `index = index_ptr.index;`` ` `    ``// Base Case: All nodes are constructed ``    ``if` `(index == n)``    ``{``        ``return` `null``;``    ``}`` ` `    ``// Allocate memory for this node ``    ``// and increment index for ``    ``// subsequent recursive calls ``    ``temp = ``new` `Node(pre[index]);``    ``(index_ptr.index)++;`` ` `    ``// If this is an internal node, ``    ``// construct left and right subtrees ``    ``// and link the subtrees ``    ``if` `(preLN[index] == ``'N'``)``    ``{``        ``temp.left = constructTreeUtil(pre, preLN, index_ptr,``                                      ``n, temp.left);``        ``temp.right = constructTreeUtil(pre, preLN, index_ptr,``                                       ``n, temp.right);``    ``}`` ` `    ``return` `temp;``}`` ` `// A wrapper over constructTreeUtil() ``public` `virtual` `Node constructTree(``int``[] pre, ``char``[] preLN, ``                                  ``int` `n, Node node)``{``    ``// Initialize index as 0. Value of ``    ``// index is used in recursion to ``    ``// maintain the current index in ``    ``// pre[] and preLN[] arrays. ``    ``int` `index = 0;`` ` `    ``return` `constructTreeUtil(pre, preLN, ``                             ``myindex, n, node);``}`` ` `/* This function is used only for testing */``public` `virtual` `void` `printInorder(Node node)``{``    ``if` `(node == ``null``)``    ``{``        ``return``;``    ``}`` ` `    ``/* first recur on left child */``    ``printInorder(node.left);`` ` `    ``/* then print the data of node */``    ``Console.Write(node.data + ``" "``);`` ` `    ``/* now recur on right child */``    ``printInorder(node.right);``}`` ` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ``GFG tree = ``new` `GFG();``    ``int``[] pre = ``new` `int``[]{10, 30, 20, 5, 15};``    ``char``[] preLN = ``new` `char``[]{``'N'``, ``'N'``, ``'L'``, ``'L'``, ``'L'``};``    ``int` `n = pre.Length;`` ` `    ``// construct the above tree ``    ``Node mynode = tree.constructTree(pre, preLN, ``                                     ``n, tree.root);`` ` `    ``// Test the constructed tree ``    ``Console.WriteLine(``"Following is Inorder Traversal of the"` `+ ``                                  ``"Constructed Binary Tree: "``);``    ``tree.printInorder(mynode);``}``}`` ` `// This code is contributed by Shrikant13`

Output:
```Following is Inorder Traversal of the Constructed Binary Tree:
20 30 5 10 15
```

Time Complexity: O(n)

Construct the full k-ary tree from its preorder traversal

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up