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<stdio.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

My Personal Notes

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

C++

Java

Python3

C#

Recommended Posts: