Check if given Preorder, Inorder and Postorder traversals are of same tree

Given Preorder, Inorder, and Postorder traversals of some tree. Write a program to check if they all are of the same tree. 
Examples: 

Input : Inorder -> 4 2 5 1 3
        Preorder -> 1 2 4 5 3
        Postorder -> 4 5 2 3 1
Output : Yes
Exaplanation : All of the above three traversals are of 
the same tree              1
                         /   \
                        2     3
                      /   \
                     4     5

Input : Inorder -> 4 2 5 1 3
        Preorder -> 1 5 4 2 3
        Postorder -> 4 1 2 3 5
Output : No 

The most basic approach to solve this problem will be to first construct a tree using two of the three given traversals and then do the third traversal on this constructed tree and compare it with the given traversal. If both of the traversals are same then print Yes otherwise print No. Here, we use Inorder and Preorder traversals to construct the tree. We may also use Inorder and Postorder traversal instead of Preorder traversal for tree construction. You may refer to this post on how to construct a tree from given Inorder and Preorder traversal. After constructing the tree, we will obtain the Postorder traversal of this tree and compare it with the given Postorder traversal.
Below is the implementation of the above approach: 
 

filter_none

edit
close

play_arrow

link
brightness_4
code

/* C++ program to check if all three given
   traversals are of the same tree */
#include <bits/stdc++.h>
using namespace std;
 
// A Binary Tree Node
struct Node
{
    int data;
    struct Node *left, *right;
};
 
// Utility function to create a new tree node
Node* newNode(int data)
{
    Node *temp = new Node;
    temp->data = data;
    temp->left = temp->right = NULL;
    return temp;
}
 
/* Function to find index of value in arr[start...end]
   The function assumes that value is present in in[] */
int search(int arr[], int strt, int end, int value)
{
    for (int i = strt; i <= end; i++)
    {
        if(arr[i] == value)
            return i;
    }
}
 
/* Recursive function to construct binary tree
   of size len from Inorder traversal in[] and
   Preorder traversal pre[].  Initial values
   of inStrt and inEnd should be 0 and len -1. 
   The function doesn't do any error checking for
   cases where inorder and preorder do not form a
   tree */
Node* buildTree(int in[], int pre[], int inStrt,
                                      int inEnd)
{
    static int preIndex = 0;
  
    if(inStrt > inEnd)
        return NULL;
  
    /* Pick current node from Preorder traversal
       using preIndex and increment preIndex */
    Node *tNode = newNode(pre[preIndex++]);
  
    /* If this node has no children then return */
    if (inStrt == inEnd)
        return tNode;
  
    /* Else find the index of this node in
       Inorder traversal */
    int inIndex = search(in, inStrt, inEnd, tNode->data);
  
    /* Using index in Inorder traversal,
       construct left and right subtress */
    tNode->left = buildTree(in, pre, inStrt, inIndex-1);
    tNode->right = buildTree(in, pre, inIndex+1, inEnd);
  
    return tNode;
}
 
/* function to compare Postorder traversal
   on constructed tree and given Postorder */
int checkPostorder(Node* node, int postOrder[], int index)
{
    if (node == NULL)
        return index;
  
    /* first recur on left child */
    index = checkPostorder(node->left,postOrder,index);
      
    /* now recur on right child */
    index = checkPostorder(node->right,postOrder,index);   
   
    /* Compare if data at current index in
       both Postorder traversals are same */
    if (node->data == postOrder[index])
        index++;
    else
        return -1;
 
    return index;
}
 
// Driver program to test above functions
int main()
{
    int inOrder[] = {4, 2, 5, 1, 3};
    int preOrder[] = {1, 2, 4, 5, 3};
    int postOrder[] = {4, 5, 2, 3, 1};
 
    int len = sizeof(inOrder)/sizeof(inOrder[0]);
 
    // build tree from given
    // Inorder and Preorder traversals
    Node *root = buildTree(inOrder, preOrder, 0, len - 1);
 
    // compare postorder traversal on constructed
    // tree with given Postorder traversal
    int index = checkPostorder(root,postOrder,0);
 
    // If both postorder traversals are same
    if (index == len)
        cout << "Yes";
    else
        cout << "No";
 
    return 0;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

/* Java program to check if all three given
traversals are of the same tree */
import java.util.*;
class GfG {
    static int preIndex = 0;
 
// A Binary Tree Node
static class Node
{
    int data;
    Node left, right;
}
 
// Utility function to create a new tree node
static Node newNode(int data)
{
    Node temp = new Node();
    temp.data = data;
    temp.left = null;
    temp.right = null;
    return temp;
}
 
/* Function to find index of value in arr[start...end]
The function assumes that value is present in in[] */
static int search(int arr[], int strt, int end, int value)
{
    for (int i = strt; i <= end; i++)
    {
        if(arr[i] == value)
            return i;
    }
    return -1;
}
 
/* Recursive function to construct binary tree
of size len from Inorder traversal in[] and
Preorder traversal pre[]. Initial values
of inStrt and inEnd should be 0 and len -1.
The function doesn't do any error checking for
cases where inorder and preorder do not form a
tree */
static Node buildTree(int in[], int pre[], int inStrt, int inEnd)
{
 
    if(inStrt > inEnd)
        return null;
 
    /* Pick current node from Preorder traversal
    using preIndex and increment preIndex */
    Node tNode = newNode(pre[preIndex++]);
 
    /* If this node has no children then return */
    if (inStrt == inEnd)
        return tNode;
 
    /* Else find the index of this node in
    Inorder traversal */
    int inIndex = search(in, inStrt, inEnd, tNode.data);
 
    /* Using index in Inorder traversal,
    construct left and right subtress */
    tNode.left = buildTree(in, pre, inStrt, inIndex-1);
    tNode.right = buildTree(in, pre, inIndex+1, inEnd);
 
    return tNode;
}
 
/* function to compare Postorder traversal
on constructed tree and given Postorder */
static int checkPostorder(Node node, int postOrder[], int index)
{
    if (node == null)
        return index;
 
    /* first recur on left child */
    index = checkPostorder(node.left,postOrder,index);
     
    /* now recur on right child */
    index = checkPostorder(node.right,postOrder,index);    
     
    /* Compare if data at current index in
    both Postorder traversals are same */
    if (node.data == postOrder[index])
        index++;
    else
        return -1;
 
    return index;
}
 
// Driver program to test above functions
public static void main(String[] args)
{
    int inOrder[] = {4, 2, 5, 1, 3};
    int preOrder[] = {1, 2, 4, 5, 3};
    int postOrder[] = {4, 5, 2, 3, 1};
 
    int len = inOrder.length;
 
    // build tree from given
    // Inorder and Preorder traversals
    Node root = buildTree(inOrder, preOrder, 0, len - 1);
 
    // compare postorder traversal on constructed
    // tree with given Postorder traversal
    int index = checkPostorder(root,postOrder,0);
 
    // If both postorder traversals are same
    if (index == len)
        System.out.println("Yes");
    else
        System.out.println("No");
 
}
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to check if
# all three given traversals
# are of the same tree
class node:
   
    def __init__(self, x):
       
        self.data = x
        self.left = None
        self.right = None
 
preIndex = 0
 
# Function to find index of value
# in arr[start...end]. The function
# assumes that value is present in in
def search(arr, strt, end, value):
   
    for i in range(strt, end + 1):
        if(arr[i] == value):
            return i
 
# Recursive function to construct
# binary tree of size lenn from
# Inorder traversal in and Preorder
# traversal pre[].  Initial values
# of inStrt and inEnd should be 0
# and lenn -1. The function doesn't
# do any error checking for cases
# where inorder and preorder do not
# form a tree
def buildTree(inn, pre, inStrt, inEnd):
   
    global preIndex
 
    if(inStrt > inEnd):
        return None
 
    # Pick current node from Preorder
    # traversal using preIndex and
    # increment preIndex
    tNode = node(pre[preIndex])
    preIndex += 1
 
    # If this node has no children
    # then return
    if (inStrt == inEnd):
        return tNode
 
    # Else find the index of this
    # node in Inorder traversal
    inIndex = search(inn, inStrt,
                     inEnd, tNode.data)
 
    # Using index in Inorder traversal,
    # construct left and right subtress
    tNode.left = buildTree(inn, pre, inStrt,
                           inIndex - 1)
    tNode.right = buildTree(inn, pre,
                            inIndex + 1, inEnd)
 
    return tNode
 
# function to compare Postorder traversal
# on constructed tree and given Postorder
def checkPostorder(node, postOrder, index):
    if (node == None):
        return index
 
    # first recur on left child
    index = checkPostorder(node.left,
                           postOrder,
                           index)
 
    # now recur on right child
    index = checkPostorder(node.right,
                           postOrder,
                           index)
 
    # Compare if data at current index in
    # both Postorder traversals are same
    if (node.data == postOrder[index]):
        index += 1
    else:
        return - 1
 
    return index
 
# Driver code
if __name__ == '__main__':
   
    inOrder = [4, 2, 5, 1, 3]
    preOrder = [1, 2, 4, 5, 3]
    postOrder = [4, 5, 2, 3, 1]
    lenn = len(inOrder)
 
    # build tree from given
    # Inorder and Preorder traversals
    root = buildTree(inOrder, preOrder,
                     0, lenn - 1)
 
    # compare postorder traversal on
    # constructed tree with given
    # Postorder traversal
    index = checkPostorder(root, postOrder, 0)
 
    # If both postorder traversals are same
    if (index == lenn):
        print("Yes")
    else:
        print("No")
 
# This code is contributed by Mohit Kumar 29
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

/* C# program to check if all three given
traversals are of the same tree */
using System;
     
public class GfG
{
    static int preIndex = 0;
 
    // A Binary Tree Node
    class Node
    {
        public int data;
        public Node left, right;
    }
 
    // Utility function to create a new tree node
    static Node newNode(int data)
    {
        Node temp = new Node();
        temp.data = data;
        temp.left = null;
        temp.right = null;
        return temp;
    }
 
    /* Function to find index of
    value in arr[start...end]
    The function assumes that
    value is present in in[] */
    static int search(int []arr, int strt,
                        int end, int value)
    {
        for (int i = strt; i <= end; i++)
        {
            if(arr[i] == value)
                return i;
        }
        return -1;
    }
 
    /* Recursive function to construct
    binary tree of size len from Inorder
    traversal in[] and Preorder traversal
    pre[]. Initial values of inStrt and
    inEnd should be 0 and len -1. The
    function doesn't do any error checking for
    cases where inorder and preorder do not form a
    tree */
    static Node buildTree(int []In, int []pre,
                            int inStrt, int inEnd)
    {
 
        if(inStrt > inEnd)
            return null;
 
        /* Pick current node from Preorder traversal
        using preIndex and increment preIndex */
        Node tNode = newNode(pre[preIndex++]);
 
        /* If this node has no children then return */
        if (inStrt == inEnd)
            return tNode;
 
        /* Else find the index of this node in
        Inorder traversal */
        int inIndex = search(In, inStrt, inEnd, tNode.data);
 
        /* Using index in Inorder traversal,
        construct left and right subtress */
        tNode.left = buildTree(In, pre, inStrt, inIndex - 1);
        tNode.right = buildTree(In, pre, inIndex + 1, inEnd);
 
        return tNode;
    }
 
    /* function to compare Postorder traversal
    on constructed tree and given Postorder */
    static int checkPostorder(Node node, int []postOrder, int index)
    {
        if (node == null)
            return index;
 
        /* first recur on left child */
        index = checkPostorder(node.left,postOrder,index);
 
        /* now recur on right child */
        index = checkPostorder(node.right,postOrder,index);    
 
        /* Compare if data at current index in
        both Postorder traversals are same */
        if (node.data == postOrder[index])
            index++;
        else
            return -1;
 
        return index;
    }
 
    // Driver code
    public static void Main()
    {
        int []inOrder = {4, 2, 5, 1, 3};
        int []preOrder = {1, 2, 4, 5, 3};
        int []postOrder = {4, 5, 2, 3, 1};
 
        int len = inOrder.Length;
 
        // build tree from given
        // Inorder and Preorder traversals
        Node root = buildTree(inOrder, preOrder, 0, len - 1);
 
        // compare postorder traversal on constructed
        // tree with given Postorder traversal
        int index = checkPostorder(root, postOrder, 0);
 
        // If both postorder traversals are same
        if (index == len)
            Console.WriteLine("Yes");
        else
            Console.WriteLine("No");
 
    }
}
 
/* This code is contributed PrinciRaj1992 */
chevron_right

Output: 
 

Yes


Time Complexity : O( n * n ), where n is number of nodes in the tree.
This article is contributed by Harsh Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
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.





Article Tags :
Practice Tags :