Construct Full Binary Tree from given preorder and postorder traversals

17 Jun, 2022
Given two arrays that represent preorder and postorder traversals of a full binary tree, construct the binary tree.A Full Binary Tree is a binary tree where every node has either 0 or 2 children
Following are examples of Full Trees. 
        1
      /   \
    2       3
  /  \     /  \
 4    5   6    7


       1
     /   \
   2      3
        /   \  
       4     5
           /   \  
          6    7
                  

          1
        /   \
      2       3
    /  \     /  \
   4    5   6    7
 /  \  
8    9 
It is not possible to construct a general Binary Tree from preorder and postorder traversals (See this). But if know that the Binary Tree is Full, we can construct the tree without ambiguity. Let us understand this with the help of following example.
Let us consider the two given arrays as pre[] = {1, 2, 4, 8, 9, 5, 3, 6, 7} and post[] = {8, 9, 4, 5, 2, 6, 7, 3, 1}; In pre[], the leftmost element is root of tree. Since the tree is full and array size is more than 1. The value next to 1 in pre[], must be left child of root. So we know 1 is root and 2 is left child. How to find the all nodes in left subtree? We know 2 is root of all nodes in left subtree. All nodes before 2 in post[] must be in left subtree. Now we know 1 is root, elements {8, 9, 4, 5, 2} are in left subtree, and the elements {6, 7, 3} are in right subtree. 
                  1
                /   \
               /      \
     {8, 9, 4, 5, 2}     {6, 7, 3}
We recursively follow the above approach and get the following tree. 
          1
        /   \
      2       3
    /  \     /  \
   4    5   6    7
  / \  
 8   9 
C++
C
Java
Python3
C#
Javascript
/* program for construction of full binary tree */#include <bits/stdc++.h>using namespace std; /* A binary tree node has data, pointer to left childand a pointer to right child */class node{    public:    int data;    node *left;    node *right;}; // A utility function to create a nodenode* newNode (int data){    node* temp = new node();     temp->data = data;    temp->left = temp->right = NULL;     return temp;} // A recursive function to construct Full from pre[] and post[].// preIndex is used to keep track of index in pre[].// l is low index and h is high index for the current subarray in post[]node* constructTreeUtil (int pre[], int post[], int* preIndex,                                int l, int h, int size){    // Base case    if (*preIndex >= size || l > h)        return NULL;     // The first node in preorder traversal is root. So take the node at    // preIndex from preorder and make it root, and increment preIndex    node* root = newNode ( pre[*preIndex] );    ++*preIndex;     // If the current subarray has only one element, no need to recur    if (l == h)        return root;     // Search the next element of pre[] in post[]    int i;    for (i = l; i <= h; ++i)        if (pre[*preIndex] == post[i])            break;     // Use the index of element found in postorder to divide        // postorder array in two parts. Left subtree and right subtree    if (i <= h)    {        root->left = constructTreeUtil (pre, post, preIndex,                                                l, i, size);        root->right = constructTreeUtil (pre, post, preIndex,                                                 i + 1, h-1, size);    }     return root;} // The main function to construct Full Binary Tree from given preorder and// postorder traversals. This function mainly uses constructTreeUtil()node *constructTree (int pre[], int post[], int size){    int preIndex = 0;    return constructTreeUtil (pre, post, &preIndex, 0, size - 1, size);} // A utility function to print inorder traversal of a Binary Treevoid printInorder (node* node){    if (node == NULL)        return;    printInorder(node->left);    cout<<node->data<<" ";    printInorder(node->right);} // Driver program to test above functionsint main (){    int pre[] = {1, 2, 4, 8, 9, 5, 3, 6, 7};    int post[] = {8, 9, 4, 5, 2, 6, 7, 3, 1};    int size = sizeof( pre ) / sizeof( pre[0] );     node *root = constructTree(pre, post, size);     cout<<"Inorder traversal of the constructed tree: \n";    printInorder(root);     return 0;} //This code is contributed by rathbhupendra
/* program for construction of full binary tree */#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;}; // A utility function to create a nodestruct node* newNode (int data){    struct node* temp = (struct node *) malloc( sizeof(struct node) );     temp->data = data;    temp->left = temp->right = NULL;     return temp;} // A recursive function to construct Full from pre[] and post[].// preIndex is used to keep track of index in pre[].// l is low index and h is high index for the current subarray in post[]struct node* constructTreeUtil (int pre[], int post[], int* preIndex,                                int l, int h, int size){    // Base case    if (*preIndex >= size || l > h)        return NULL;     // The first node in preorder traversal is root. So take the node at    // preIndex from preorder and make it root, and increment preIndex    struct node* root = newNode ( pre[*preIndex] );    ++*preIndex;     // If the current subarray has only one element, no need to recur    if (l == h)        return root;     // Search the next element of pre[] in post[]    int i;    for (i = l; i <= h; ++i)        if (pre[*preIndex] == post[i])            break;     // Use the index of element found in postorder to divide    // postorder array in two parts. Left subtree and right subtree    if (i <= h)    {        root->left = constructTreeUtil (pre, post, preIndex,                                        l, i, size);        root->right = constructTreeUtil (pre, post, preIndex,                                         i + 1, h-1, size);    }     return root;} // The main function to construct Full Binary Tree from given preorder and// postorder traversals. This function mainly uses constructTreeUtil()struct node *constructTree (int pre[], int post[], int size){    int preIndex = 0;    return constructTreeUtil (pre, post, &preIndex, 0, size - 1, size);} // A utility function to print inorder traversal of a Binary Treevoid printInorder (struct node* node){    if (node == NULL)        return;    printInorder(node->left);    printf("%d ", node->data);    printInorder(node->right);} // Driver program to test above functionsint main (){    int pre[] = {1, 2, 4, 8, 9, 5, 3, 6, 7};    int post[] = {8, 9, 4, 5, 2, 6, 7, 3, 1};    int size = sizeof( pre ) / sizeof( pre[0] );     struct node *root = constructTree(pre, post, size);     printf("Inorder traversal of the constructed tree: \n");    printInorder(root);     return 0;}
// Java program for construction// of full binary treepublic class fullbinarytreepostpre{    // variable to hold index in pre[] array    static int preindex;     static class node    {        int data;        node left, right;         public node(int data)        {            this.data = data;        }    }     // A recursive function to construct Full    // from pre[] and post[]. preIndex is used    // to keep track of index in pre[]. l is    // low index and h is high index for the    // current subarray in post[]    static node constructTreeUtil(int pre[], int post[], int l,                                   int h, int size)    {                 // Base case        if (preindex >= size || l > h)            return null;         // The first node in preorder traversal is        // root. So take the node at preIndex from        // preorder and make it root, and increment        // preIndex        node root = new node(pre[preindex]);        preindex++;                 // If the current subarray has only one        // element, no need to recur or        // preIndex > size after incrementing        if (l == h || preindex >= size)            return root;        int i;                 // Search the next element of pre[] in post[]        for (i = l; i <= h; i++)        {            if (post[i] == pre[preindex])                break;        }        // Use the index of element found in        // postorder to divide postorder array        // in two parts. Left subtree and right subtree        if (i <= h)        {            root.left = constructTreeUtil(pre, post, l, i, size);            root.right = constructTreeUtil(pre, post, i + 1, h-1, size);        }        return root;    }     // The main function to construct Full    // Binary Tree from given preorder and    // postorder traversals. This function    // mainly uses constructTreeUtil()    static node constructTree(int pre[], int post[], int size)    {        preindex = 0;        return constructTreeUtil(pre, post, 0, size - 1, size);    }     static void printInorder(node root)    {        if (root == null)            return;        printInorder(root.left);        System.out.print(root.data + " ");        printInorder(root.right);    }     public static void main(String[] args)    {         int pre[] = { 1, 2, 4, 8, 9, 5, 3, 6, 7 };        int post[] = { 8, 9, 4, 5, 2, 6, 7, 3, 1 };         int size = pre.length;        node root = constructTree(pre, post, size);         System.out.println("Inorder traversal of the constructed tree:");        printInorder(root);    }} // This code is contributed by Rishabh Mahrsee
# Python3 program for construction of# full binary tree # A binary tree node has data, pointer# to left child and a pointer to right childclass Node:         def __init__(self, data):                 self.data = data        self.left = None        self.right = None # A recursive function to construct# Full from pre[] and post[].# preIndex is used to keep track# of index in pre[]. l is low index# and h is high index for the# current subarray in post[]def constructTreeUtil(pre: list, post: list,                        l: int, h: int,                     size: int) -> Node:    global preIndex         # Base case    if (preIndex >= size or l > h):        return None     # The first node in preorder traversal    # is root. So take the node at preIndex    # from preorder and make it root, and    # increment preIndex    root = Node(pre[preIndex])    preIndex += 1     # If the current subarray has only    # one element, no need to recur    if (l == h or preIndex >= size):        return root     # Search the next element    # of pre[] in post[]    i = l    while i <= h:        if (pre[preIndex] == post[i]):            break                 i += 1     # Use the index of element    # found in postorder to divide    # postorder array in two parts.    # Left subtree and right subtree    if (i <= h):        root.left = constructTreeUtil(pre, post,                                      l, i, size)        root.right = constructTreeUtil(pre, post,                                       i + 1, h-1,                                       size)     return root # The main function to construct# Full Binary Tree from given# preorder and postorder traversals.# This function mainly uses constructTreeUtil()def constructTree(pre: list,                 post: list,                 size: int) -> Node:                          global preIndex         return constructTreeUtil(pre, post, 0,                             size - 1, size) # A utility function to print# inorder traversal of a Binary Treedef printInorder(node: Node) -> None:     if (node is None):        return         printInorder(node.left)    print(node.data, end = " ")         printInorder(node.right) # Driver codeif __name__ == "__main__":         pre = [ 1, 2, 4, 8, 9, 5, 3, 6, 7 ]    post = [ 8, 9, 4, 5, 2, 6, 7, 3, 1 ]    size = len(pre)     preIndex = 0     root = constructTree(pre, post, size)     print("Inorder traversal of "          "the constructed tree: ")               printInorder(root) # This code is contributed by sanjeev2552
// C# program for construction// of full binary treeusing System; class GFG{// variable to hold index in pre[] arraypublic static int preindex; public class node{    public int data;    public node left, right;     public node(int data)    {        this.data = data;    }} // A recursive function to construct Full// from pre[] and post[]. preIndex is used// to keep track of index in pre[]. l is// low index and h is high index for the// current subarray in post[]public static node constructTreeUtil(int[] pre, int[] post,                                     int l, int h, int size){     // Base case    if (preindex >= size || l > h)    {        return null;    }     // The first node in preorder traversal is    // root. So take the node at preIndex from    // preorder and make it root, and increment    // preIndex    node root = new node(pre[preindex]);    preindex++;     // If the current subarray has only one    // element, no need to recur or    // preIndex > size after incrementing    if (l == h || preindex >= size)    {        return root;    }    int i;     // Search the next element    // of pre[] in post[]    for (i = l; i <= h; i++)    {        if (post[i] == pre[preindex])        {            break;        }    }         // Use the index of element found    // in postorder to divide postorder    // array in two parts. Left subtree    // and right subtree    if (i <= h)    {        root.left = constructTreeUtil(pre, post,                                      l, i, size);        root.right = constructTreeUtil(pre, post,                                       i + 1, h-1, size);    }    return root;} // The main function to construct Full// Binary Tree from given preorder and// postorder traversals. This function// mainly uses constructTreeUtil()public static node constructTree(int[] pre,                                 int[] post, int size){    preindex = 0;    return constructTreeUtil(pre, post, 0, size - 1, size);} public static void printInorder(node root){    if (root == null)    {        return;    }    printInorder(root.left);    Console.Write(root.data + " ");    printInorder(root.right);} // Driver Codepublic static void Main(string[] args){    int[] pre = new int[] {1, 2, 4, 8, 9, 5, 3, 6, 7};    int[] post = new int[] {8, 9, 4, 5, 2, 6, 7, 3, 1};     int size = pre.Length;    node root = constructTree(pre, post, size);     Console.WriteLine("Inorder traversal of " +                      "the constructed tree:");    printInorder(root);}} // This code is contributed by Shrikant13
<script>  // Javascript program for construction// of full binary tree // variable to hold index in pre[] arrayvar preindex = 0; class node{    constructor(data)    {        this.data = data;    }} // A recursive function to construct Full// from pre[] and post[]. preIndex is used// to keep track of index in pre[]. l is// low index and h is high index for the// current subarray in post[]function constructTreeUtil(pre, post, l, h, size){     // Base case    if (preindex >= size || l > h)    {        return null;    }     // The first node in preorder traversal is    // root. So take the node at preIndex from    // preorder and make it root, and increment    // preIndex    var root = new node(pre[preindex]);    preindex++;     // If the current subarray has only one    // element, no need to recur or    // preIndex > size after incrementing    if (l == h || preindex >= size)    {        return root;    }    var i;     // Search the next element    // of pre[] in post[]    for (i = l; i <= h; i++)    {        if (post[i] == pre[preindex])        {            break;        }    }         // Use the index of element found    // in postorder to divide postorder    // array in two parts. Left subtree    // and right subtree    if (i <= h)    {        root.left = constructTreeUtil(pre, post,                                      l, i, size);        root.right = constructTreeUtil(pre, post,                                       i + 1, h-1, size);    }    return root;} // The main function to construct Full// Binary Tree from given preorder and// postorder traversals. This function// mainly uses constructTreeUtil()function constructTree(pre, post, size){    preindex = 0;    return constructTreeUtil(pre, post, 0, size - 1, size);} function printInorder(root){    if (root == null)    {        return;    }    printInorder(root.left);    document.write(root.data + " ");    printInorder(root.right);} // Driver Codevar pre = [1, 2, 4, 8, 9, 5, 3, 6, 7];var post = [8, 9, 4, 5, 2, 6, 7, 3, 1];var size = pre.length;var root = constructTree(pre, post, size);document.write("Inorder traversal of " +                  "the constructed tree:<br>");printInorder(root);  </script>
Inorder traversal of the constructed tree: 
8 4 9 2 5 1 6 3 7 
shrikanth13
rathbhupendra
sanjeev2552
rutvik_56
parthagarwal1962000
as5853535
hardikkoriintern
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.