Construct a special tree from given preorder traversal

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<bits/stdc++.h> 
  
/* 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[0]); 
  
    // 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.

My Personal Notes

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

C++

Java

Python3

C#

Recommended Posts: