Construct Special Binary Tree from given Inorder traversal

17 Jun, 2022
Given Inorder Traversal of a Special Binary Tree in which key of every node is greater than keys in left and right children, construct the Binary Tree and return root.
Examples: 
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
Input: inorder[] = {5, 10, 40, 30, 28}
Output: root of following tree
         40
       /   \
      10     30
     /         \
    5          28 

Input: inorder[] = {1, 5, 10, 40, 30, 
                    15, 28, 20}
Output: root of following tree
          40
        /   \
       10     30
      /         \
     5          28
    /          /  \
   1         15    20
The idea used in Construction of Tree from given Inorder and Preorder traversals can be used here. Let the given array is {1, 5, 10, 40, 30, 15, 28, 20}. The maximum element in given array must be root. The elements on left side of the maximum element are in left subtree and elements on right side are in right subtree. 
         40
      /       \  
   {1,5,10}   {30,15,28,20}
We recursively follow above step for left and right subtrees, and finally get the following tree.
          40
        /   \
       10     30
      /         \
     5          28
    /          /  \
   1         15    20
Algorithm: buildTree() 
Find index of the maximum element in array. The maximum element must be root of Binary Tree. Create a new tree node ‘root’ with the data as the maximum value found in step 1. Call buildTree for elements before the maximum element and make the built tree as left subtree of ‘root’. Call buildTree for elements after the maximum element and make the built tree as right subtree of ‘root’. return ‘root’.
Find index of the maximum element in array. The maximum element must be root of Binary Tree. 
Create a new tree node ‘root’ with the data as the maximum value found in step 1. 
Call buildTree for elements before the maximum element and make the built tree as left subtree of ‘root’. 
Call buildTree for elements after the maximum element and make the built tree as right subtree of ‘root’. 
return ‘root’.
Implementation: Following is the implementation of the above algorithm. 
C++
C
Java
Python3
C#
Javascript
/* C++ program to construct treefrom inorder traversal */#include <bits/stdc++.h>using namespace std; /* A binary tree node has data,pointer to left child anda pointer to right child */class node{    public:    int data;    node* left;    node* right;}; /* Prototypes of a utility function to get the maximumvalue in inorder[start..end] */int max(int inorder[], int strt, int end); /* A utility function to allocate memory for a node */node* newNode(int data); /* Recursive function to construct binary of size len fromInorder traversal inorder[]. Initial values of start and endshould be 0 and len -1. */node* buildTree (int inorder[], int start, int end){    if (start > end)        return NULL;     /* Find index of the maximum element from Binary Tree */    int i = max (inorder, start, end);     /* Pick the maximum value and make it root */    node *root = newNode(inorder[i]);     /* If this is the only element in inorder[start..end],    then return it */    if (start == end)        return root;     /* Using index in Inorder traversal, construct left and    right subtress */    root->left = buildTree (inorder, start, i - 1);    root->right = buildTree (inorder, i + 1, end);     return root;} /* UTILITY FUNCTIONS *//* Function to find index of the maximum value in arr[start...end] */int max (int arr[], int strt, int end){    int i, max = arr[strt], maxind = strt;    for(i = strt + 1; i <= end; i++)    {        if(arr[i] > max)        {            max = arr[i];            maxind = i;        }    }    return maxind;} /* Helper function that allocates a new node with thegiven data and NULL left and right pointers. */node* newNode (int data){    node* Node = new node();    Node->data = data;    Node->left = NULL;    Node->right = NULL;     return Node;} /* This function is here just to test buildTree() */void printInorder (node* node){    if (node == NULL)        return;     /* first recur on left child */    printInorder (node->left);     /* then print the data of node */    cout<<node->data<<" ";     /* now recur on right child */    printInorder (node->right);} /* Driver code*/int main(){    /* Assume that inorder traversal of following tree is given        40        / \        10 30        /     \        5     28 */     int inorder[] = {5, 10, 40, 30, 28};    int len = sizeof(inorder)/sizeof(inorder[0]);    node *root = buildTree(inorder, 0, len - 1);     /* Let us test the built tree by printing Inorder traversal */    cout << "Inorder traversal of the constructed tree is \n";    printInorder(root);    return 0;} // This is code is contributed by rathbhupendra
/* program to construct tree from inorder traversal */#include<stdio.h>#include<stdlib.h> /* A binary tree node has data, pointer to left child   and a pointer to right child */struct node{    int data;    struct node* left;    struct node* right;}; /* Prototypes of a utility function to get the maximum   value in inorder[start..end] */int max(int inorder[], int strt, int end); /* A utility function to allocate memory for a node */struct node* newNode(int data); /* Recursive function to construct binary of size len from   Inorder traversal inorder[]. Initial values of start and end   should be 0 and len -1.  */struct node* buildTree (int inorder[], int start, int end){    if (start > end)        return NULL;     /* Find index of the maximum element from Binary Tree */    int i = max (inorder, start, end);     /* Pick the maximum value and make it root */    struct node *root = newNode(inorder[i]);     /* If this is the only element in inorder[start..end],       then return it */    if (start == end)        return root;     /* Using index in Inorder traversal, construct left and       right subtress */    root->left  = buildTree (inorder, start, i-1);    root->right = buildTree (inorder, i+1, end);     return root;} /* UTILITY FUNCTIONS *//* Function to find index of the maximum value in arr[start...end] */int max (int arr[], int strt, int end){    int i, max = arr[strt], maxind = strt;    for(i = strt+1; i <= end; i++)    {        if(arr[i] > max)        {            max = arr[i];            maxind = i;        }    }    return maxind;} /* Helper function that allocates a new node with the   given data and NULL left and right pointers. */struct node* newNode (int data){    struct node* node = (struct node*)malloc(sizeof(struct node));    node->data = data;    node->left = NULL;    node->right = NULL;     return node;} /* This function is here just to test buildTree() */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 program to test above functions */int main(){   /* Assume that inorder traversal of following tree is given         40       /   \      10     30     /         \    5          28 */     int inorder[] = {5, 10, 40, 30, 28};    int len = sizeof(inorder)/sizeof(inorder[0]);    struct node *root = buildTree(inorder, 0, len - 1);     /* Let us test the built tree by printing Inorder traversal */    printf("\n Inorder traversal of the constructed tree is \n");    printInorder(root);    return 0;}
// Java program to construct tree from inorder traversal  /* A binary tree node has data, pointer to left child   and a pointer to right child */class Node{    int data;    Node left, right;      Node(int item)    {        data = item;        left = right = null;    }}  class BinaryTree{    Node root;      /* Recursive function to construct binary of size len from       Inorder traversal inorder[]. Initial values of start and end       should be 0 and len -1.  */    Node buildTree(int inorder[], int start, int end, Node node)    {        if (start > end)            return null;          /* Find index of the maximum element from Binary Tree */        int i = max(inorder, start, end);          /* Pick the maximum value and make it root */        node = new Node(inorder[i]);          /* If this is the only element in inorder[start..end],         then return it */        if (start == end)            return node;          /* Using index in Inorder traversal, construct left and         right subtress */        node.left = buildTree(inorder, start, i - 1, node.left);        node.right = buildTree(inorder, i + 1, end, node.right);          return node;    }      /* UTILITY FUNCTIONS */         /* Function to find index of the maximum value in arr[start...end] */    int max(int arr[], int strt, int end)    {        int i, max = arr[strt], maxind = strt;        for (i = strt + 1; i <= end; i++)        {            if (arr[i] > max)            {                max = arr[i];                maxind = i;            }        }        return maxind;    }      /* This function is here just to test buildTree() */    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);    }      public static void main(String args[])    {        BinaryTree tree = new BinaryTree();                 /* Assume that inorder traversal of following tree is given             40            /   \          10     30         /         \        5          28 */        int inorder[] = new int[]{5, 10, 40, 30, 28};        int len = inorder.length;        Node mynode = tree.buildTree(inorder, 0, len - 1, tree.root);          /* Let us test the built tree by printing Inorder traversal */        System.out.println("Inorder traversal of the constructed tree is ");        tree.printInorder(mynode);    }}  // This code has been contributed by Mayank Jaiswal
# Python3 program to construct tree from# inorder traversal # Helper class that allocates a new node# with the given data and None left and# right pointers.class newNode:    def __init__(self, data):        self.data = data        self.left = None        self.right = None # Prototypes of a utility function to get# the maximum value in inorder[start..end] # Recursive function to construct binary of# size len from Inorder traversal inorder[].# Initial values of start and end should be# 0 and len -1.def buildTree (inorder, start, end):    if start > end:        return None     # Find index of the maximum element    # from Binary Tree    i = Max (inorder, start, end)     # Pick the maximum value and make it root    root = newNode(inorder[i])     # If this is the only element in    # inorder[start..end], then return it    if start == end:        return root     # Using index in Inorder traversal,    # construct left and right subtress    root.left = buildTree (inorder, start, i - 1)    root.right = buildTree (inorder, i + 1, end)     return root # UTILITY FUNCTIONS # Function to find index of the maximum# value in arr[start...end]def Max(arr, strt, end):    i, Max = 0, arr[strt]    maxind = strt    for i in range(strt + 1, end + 1):        if arr[i] > Max:            Max = arr[i]            maxind = i    return maxind # This function is here just to test buildTree()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 Codeif __name__ == '__main__':         # Assume that inorder traversal of    # following tree is given    #     40    # / \    # 10     30    # /         \    #5         28     inorder = [5, 10, 40, 30, 28]    Len = len(inorder)    root = buildTree(inorder, 0, Len - 1)     # Let us test the built tree by    # printing Inorder traversal    print("Inorder traversal of the",              "constructed tree is ")    printInorder(root)     # This code is contributed by PranchalK
// C# program to construct tree// from inorder traversalusing System; /* A binary tree node has data,pointer to left child and a pointerto right child */public class Node{    public int data;    public Node left, right;     public Node(int item)    {        data = item;        left = right = null;    }} class GFG{public Node root; /* Recursive function to construct binaryof size len from Inorder traversal inorder[].Initial values of start and end should be 0and len -1. */public virtual Node buildTree(int[] inorder, int start,                              int end, Node node){    if (start > end)    {        return null;    }     /* Find index of the maximum    element from Binary Tree */    int i = max(inorder, start, end);     /* Pick the maximum value and    make it root */    node = new Node(inorder[i]);     /* If this is the only element in    inorder[start..end], then return it */    if (start == end)    {        return node;    }     /* Using index in Inorder traversal,    construct left and right subtress */    node.left = buildTree(inorder, start,                          i - 1, node.left);    node.right = buildTree(inorder, i + 1,                           end, node.right);     return node;} /* UTILITY FUNCTIONS */ /* Function to find index of themaximum value in arr[start...end] */public virtual int max(int[] arr,                       int strt, int end){    int i, max = arr[strt], maxind = strt;    for (i = strt + 1; i <= end; i++)    {        if (arr[i] > max)        {            max = arr[i];            maxind = i;        }    }    return maxind;} /* This function is here just   to test buildTree() */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 Codepublic static void Main(string[] args){    GFG tree = new GFG();     /* Assume that inorder traversal       of following tree is given        40        / \    10     30    /         \    5         28 */    int[] inorder = new int[]{5, 10, 40, 30, 28};    int len = inorder.Length;    Node mynode = tree.buildTree(inorder, 0,                                 len - 1, tree.root);     /* Let us test the built tree by       printing Inorder traversal */    Console.WriteLine("Inorder traversal of " +                   "the constructed tree is ");    tree.printInorder(mynode);}} // This code is contributed by Shrikant13
<script>  // JavaScript program to construct tree// from inorder traversal /* A binary tree node has data,pointer to left child and a pointerto right child */class Node{    constructor(item)    {        this.data = item;        this.left = null;        this.right = null;    }} var root = null; /* Recursive function to construct binaryof size len from Inorder traversal inorder[].Initial values of start and end should be 0and len -1. */function buildTree(inorder, start, end, node){    if (start > end)    {        return null;    }     /* Find index of the maximum    element from Binary Tree */    var i = max(inorder, start, end);     /* Pick the maximum value and    make it root */    node = new Node(inorder[i]);     /* If this is the only element in    inorder[start..end], then return it */    if (start == end)    {        return node;    }     /* Using index in Inorder traversal,    construct left and right subtress */    node.left = buildTree(inorder, start,                          i - 1, node.left);    node.right = buildTree(inorder, i + 1,                           end, node.right);     return node;} /* UTILITY FUNCTIONS */ /* Function to find index of themaximum value in arr[start...end] */function max(arr, strt, end){    var i, maxi = arr[strt], maxind = strt;    for (i = strt + 1; i <= end; i++)    {        if (arr[i] > maxi)        {            maxi = arr[i];            maxind = i;        }    }    return maxind;} /* This function is here just   to test buildTree() */function printInorder(node){    if (node == null)    {        return;    }     /* first recur on left child */    printInorder(node.left);     /* then print the data of node */    document.write(node.data + " ");     /* now recur on right child */    printInorder(node.right);} // Driver Code /* Assume that inorder traversal   of following tree is given    40    / \10     30/         \5         28 */var inorder = [5, 10, 40, 30, 28];var len = inorder.length;var mynode = buildTree(inorder, 0, len - 1, root);/* Let us test the built tree by   printing Inorder traversal */document.write("Inorder traversal of " +               "the constructed tree is <br>");printInorder(mynode);  </script>
Inorder traversal of the constructed tree is 
5 10 40 30 28 
Time Complexity: O(n^2) 
shrikanth13
PranchalKatiyar
rathbhupendra
rutvik_56
simranarora5sos
kalrap615
hardikkoriintern
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.