# 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 1Output : YesExplanation : All of the above three traversals are of the same tree   1                         /   \                        2     3                      /   \                     4     5Input : Inorder -> 4 2 5 1 3        Preorder -> 1 5 4 2 3        Postorder -> 4 1 2 3 5Output : 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:

## C++

## Java

## Python3

## C#

## Javascript

Output
```Yes

```

Time Complexity : O( n * n ), where n is number of nodes in the tree.
Space Complexity: O(n), for call stack

Efficient algorithm using hash map to store indices of inorder elements :

While building the tree from Inorder and Preorder traversal we need to check if the inorder and preorder traversals are valid themself for some tree, and if yes , then keep building the tree, but if valid binary tree can not be built from given inorder and preorder traversal, then we must stop building the tree and return false. And also we can build the tree from inorder and preorder traversal in O(n) time using hashmap to store the indices of the inorder elements’ array.

Implementation:

## C++

## Java

 `
``// Java code for the above approach
import java.util.*;

class Node {
int data;
Node left, right;

Node(int val)
{
data = val;
left = right = null;
}
}

class Main {
static Node buildTreeFromInorderPreorder(
int inStart, int inEnd, int[] preorder,
Map inorderIndexMap,
boolean[] notPossible, int preIndex)
{

if (inStart > inEnd)
return null;

// build the current Node
int rootData = preorder[preIndex];
Node root = new Node(rootData);
preIndex++;

// find the node in inorderIndexMap
if (!inorderIndexMap.containsKey(rootData)) {
notPossible[0] = true;
return root;
}
int inorderIndex = inorderIndexMap.get(rootData);
if (!(inStart <= inorderIndex
&& inorderIndex <= inEnd)) {
notPossible[0] = true;
return root;
}

int leftInorderStart = inStart,
leftInorderEnd = inorderIndex - 1,
rightInorderStart = inorderIndex + 1,
rightInorderEnd = inEnd;

root.left = buildTreeFromInorderPreorder(
leftInorderStart, leftInorderEnd, preorder,
inorderIndexMap, notPossible, preIndex);

if (notPossible[0])
return root;

root.right = buildTreeFromInorderPreorder(
rightInorderStart, rightInorderEnd, preorder,
inorderIndexMap, notPossible, preIndex);

return root;
}

static boolean checkPostorderCorrect(Node root,
int[] postorder,
int postIndex)
{
if (root == null)
return true;

if (!checkPostorderCorrect(root.left, postorder,
postIndex))
return false;
if (!checkPostorderCorrect(root.right, postorder,
postIndex))
return false;

return (root.data == postorder[postIndex++]);
}

static boolean checktree(int[] preorder, int[] inorder,
int[] postorder, int N)
{
if (N == 0)
return true;

Map inorderIndexMap
= new HashMap<>();
for (int i = 0; i < N; i++)
inorderIndexMap.put(inorder[i], i);

int preIndex = 0;
boolean[] notPossible = new boolean[] { false };

Node root = buildTreeFromInorderPreorder(
0, N - 1, preorder, inorderIndexMap,
notPossible, preIndex);

if (notPossible[0])
return true;

int postIndex = 0;

return checkPostorderCorrect(root, postorder,
postIndex);
}

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;

if (checktree(preOrder, inOrder, postOrder, len))
System.out.println("The tree is valid");
else
System.out.println("The tree is not valid");
}
}

// This code is contributed by lokeshpotta20.
`

## Python3

 `# Python3 program for the above approach ``class` `Node: ``    ``def` `__init__(``self``, x): ``        ``self``.data ``=` `x ``        ``self``.left ``=` `None``        ``self``.right ``=` `None`` ` ` ` `preIndex ``=` `0``notPossible ``=` `False`` ` ` ` `def` `buildTreeFromInorderPreorder(inStart, inEnd, preorder, inorderIndexMap): ``    ``if``(inStart > inEnd): ``        ``return` `None`` ` `    ``# build the current node ``    ``global` `preIndex ``    ``global` `notPossible ``    ``rootData ``=` `preorder[preIndex] ``    ``root ``=` `Node(rootData) ``    ``preIndex ``+``=` `1`` ` `    ``# find the node in inorderIndexMap ``    ``if``(inorderIndexMap.get(rootData) ``=``=` `None``): ``        ``notPossible ``=` `True``        ``return` `root `` ` `    ``inorderIndex ``=` `inorderIndexMap.get(rootData) ``    ``if``((inStart <``=` `inorderIndex ``and` `inorderIndex <``=` `inEnd) ``=``=` `False``): ``        ``notPossible ``=` `True``        ``return` `root `` ` `    ``leftInorderStart ``=` `inStart ``    ``leftInorderEnd ``=` `inorderIndex ``-` `1``    ``rightInorderStart ``=` `inorderIndex ``+` `1``    ``rightInroderEnd ``=` `inEnd `` ` `    ``root.left ``=` `buildTreeFromInorderPreorder( ``        ``leftInorderStart, leftInorderEnd, preorder, inorderIndexMap) `` ` `    ``if``(notPossible ``=``=` `True``): ``        ``return` `root `` ` `    ``root.right ``=` `buildTreeFromInorderPreorder( ``        ``rightInorderStart, rightInroderEnd, preorder, inorderIndexMap) `` ` `    ``return` `root `` ` ` ` `postIndex ``=` `0`` ` ` ` `def` `checkPostorderCorrect(root, postOrder): ``    ``if``(root ``=``=` `None``): ``        ``return` `True``    ``if``(checkPostorderCorrect(root.left, postOrder) ``=``=` `False``): ``        ``return` `False`` ` `    ``if``(checkPostorderCorrect(root.right, postOrder) ``=``=` `False``): ``        ``return` `False`` ` `    ``global` `postIndex ``    ``if``(root.data ``=``=` `postOrder[postIndex]): ``        ``postIndex ``+``=` `1``        ``return` `True``    ``else``: ``        ``postIndex ``+``=` `1``        ``return` `False`` ` ` ` `def` `printPostorder(root): ``    ``if``(root ``=``=` `None``): ``        ``return`` ` `    ``printPostorder(root.left) ``    ``printPostorder(root.right) ``    ``print``(root.data) `` ` ` ` `def` `printInorder(root): ``    ``if``(root ``=``=` `None``): ``        ``return`` ` `    ``printInorder(root.left) ``    ``print``(root.data) ``    ``printInorder(root.right) `` ` ` ` `def` `checktree(preorder, inorder, postorder, N): ``    ``if``(N ``=``=` `0``): ``        ``return` `True``    ``inorderIndexMap ``=` `{} ``    ``for` `i ``in` `range``(N): ``        ``inorderIndexMap[inorder[i]] ``=` `i `` ` `    ``root ``=` `buildTreeFromInorderPreorder(``0``, N``-``1``, preorder, inorderIndexMap) `` ` `    ``global` `notPossible ``    ``if``(notPossible ``=``=` `True``): ``        ``return` `False`` ` `    ``if``(checkPostorderCorrect(root, postorder)): ``        ``return` `True``    ``else``: ``        ``return` `False`` ` ` ` `# driver program ``inOrder ``=` `[``4``, ``2``, ``5``, ``1``, ``3``] ``preOrder ``=` `[``1``, ``2``, ``4``, ``5``, ``3``] ``postOrder ``=` `[``4``, ``5``, ``2``, ``3``, ``1``] `` ` `len` `=` `len``(inOrder) `` ` `# if both postorder traversal as same ``if``(checktree(preOrder, inOrder, postOrder, ``len``) ``=``=` `True``): ``    ``print``(``"Yes"``) ``else``: ``    ``print``(``"No"``) `` ` `# THIS CODE IS CONTRIBUTED BY KIRTI AGARWAL(KIRTIAGARWAL23121999) `

## C#

 `using` `System; ``using` `System.Collections.Generic; `` ` `class` `Node ``{ ``    ``public` `int` `data; ``    ``public` `Node left; ``    ``public` `Node right; `` ` `    ``public` `Node(``int` `val) ``    ``{ ``        ``data = val; ``        ``left = right = ``null``; ``    ``} ``} `` ` `class` `Program ``{ ``    ``static` `Node BuildTreeFromInorderPreorder(``int` `inStart, ``int` `inEnd, ``int``[] preorder, Dictionary<``int``, ``int``> inorderIndexMap, ``ref` `bool` `notPossible, ``ref` `int` `preIndex) ``    ``{ ``        ``if` `(inStart > inEnd) ``            ``return` `null``; `` ` `        ``// Build the current node ``        ``int` `rootData = preorder[preIndex]; ``        ``Node root = ``new` `Node(rootData); ``        ``preIndex++; `` ` `        ``// Find the node in inorderIndexMap ``        ``if` `(!inorderIndexMap.ContainsKey(rootData)) ``        ``{ ``            ``notPossible = ``true``; ``            ``return` `root; ``        ``} `` ` `        ``int` `inorderIndex = inorderIndexMap[rootData]; ``        ``if` `(!(inStart <= inorderIndex && inorderIndex <= inEnd)) ``        ``{ ``            ``notPossible = ``true``; ``            ``return` `root; ``        ``} `` ` `        ``int` `leftInorderStart = inStart; ``        ``int` `leftInorderEnd = inorderIndex - 1; ``        ``int` `rightInorderStart = inorderIndex + 1; ``        ``int` `rightInorderEnd = inEnd; `` ` `        ``root.left = BuildTreeFromInorderPreorder(leftInorderStart, leftInorderEnd, preorder, inorderIndexMap, ``ref` `notPossible, ``ref` `preIndex); `` ` `        ``if` `(notPossible) ``            ``return` `root; `` ` `        ``root.right = BuildTreeFromInorderPreorder(rightInorderStart, rightInorderEnd, preorder, inorderIndexMap, ``ref` `notPossible, ``ref` `preIndex); `` ` `        ``return` `root; ``    ``} `` ` `    ``static` `bool` `CheckPostorderCorrect(Node root, ``int``[] postorder, ``ref` `int` `postIndex) ``    ``{ ``        ``if` `(root == ``null``) ``            ``return` `true``; `` ` `        ``if` `(!CheckPostorderCorrect(root.left, postorder, ``ref` `postIndex)) ``            ``return` `false``; `` ` `        ``if` `(!CheckPostorderCorrect(root.right, postorder, ``ref` `postIndex)) ``            ``return` `false``; `` ` `        ``return` `(root.data == postorder[postIndex++]); ``    ``} `` ` `    ``static` `bool` `CheckTree(``int``[] preorder, ``int``[] inorder, ``int``[] postorder, ``int` `N) ``    ``{ ``        ``if` `(N == 0) ``            ``return` `true``; `` ` `        ``Dictionary<``int``, ``int``> inorderIndexMap = ``new` `Dictionary<``int``, ``int``>(); ``        ``for` `(``int` `i = 0; i < N; i++) ``            ``inorderIndexMap.Add(inorder[i], i); `` ` `        ``int` `preIndex = 0; ``        ``bool` `notPossible = ``false``; `` ` `        ``Node root = BuildTreeFromInorderPreorder(0, N - 1, preorder, inorderIndexMap, ``ref` `notPossible, ``ref` `preIndex); `` ` `        ``if` `(notPossible) ``            ``return` `false``; `` ` `        ``int` `postIndex = 0; `` ` `        ``return` `CheckPostorderCorrect(root, postorder, ``ref` `postIndex); ``    ``} `` ` `     ``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; `` ` `    ``if` `(CheckTree(preOrder, inOrder, postOrder, len)) ``      ``Console.WriteLine(``"Yes"``); ``    ``else``      ``Console.WriteLine(``"No"``); ``  ``} ``} `

## Javascript

 `// JavaScript program for the above approach ``class Node{ ``    ``constructor(val){ ``        ``this``.data = val; ``        ``this``.left = ``null``; ``        ``this``.right =  ``null``; ``    ``} ``} `` ` `let preIndex = 0; ``let notPossible = ``false``; ``function` `buildTreeFromInorderPreorder(inStart, inEnd,  ``preorder, inorderIndexMap){ ``    ``if``(inStart > inEnd){ ``        ``return` `null``; ``    ``} ``     ` `    ``// build the current node ``    ``let rootData = preorder[preIndex]; ``    ``let root = ``new` `Node(rootData); ``    ``preIndex++; ``     ` `    ``// find the node in inorderIndexMap ``    ``if``(inorderIndexMap.has(rootData) == ``false``){ ``        ``notPossible = ``true``; ``        ``return` `root; ``    ``} ``     ` `    ``let inorderIndex = inorderIndexMap.get(rootData); ``    ``if``(!(inStart <= inorderIndex && inorderIndex <= inEnd)){ ``        ``notPosstible = ``true``; ``        ``return` `root; ``    ``} ``     ` `    ``let leftInorderStart = inStart; ``    ``let leftInorderEnd = inorderIndex - 1; ``    ``let rightInorderStart = inorderIndex + 1; ``    ``let rightInorderEnd = inEnd; ``         ` `    ``root.left = buildTreeFromInorderPreorder( ``        ``leftInorderStart, leftInorderEnd, preorder, inorderIndexMap); ``         ` `    ``if``(notPossible == ``true``) ``        ``return` `root; ``     ` `    ``root.right = buildTreeFromInorderPreorder( ``        ``leftInorderStart, leftInorderEnd, preorder, inorderIndexMap); ``     ` `    ``return` `root; ``} `` ` `let postIndex = 0; ``function` `checkPostorderCorrect(root, postOrder){ ``    ``if``(root == ``null``) ``return` `true``; ``    ``if``(!checkPostorderCorrect(root.left, postOrder)) ``        ``return` `false``; ``     ` `    ``if``(!checkPostorderCorrect(root.right, postOrder)) ``        ``return` `false``; ``         ` `    ``return` `(root.data == postOrder[postIndex++]); ``} `` ` `function` `printPostorder(root){ ``    ``if``(root == ``null``) ``return``; ``     ` `    ``printPostorder(root.left); ``    ``printPostorder(root.right); ``    ``document.write(root.data + ``" "``); ``} `` ` `function` `printInorder(root){ ``    ``if``(root == ``null``) ``return``; ``    ``printInorder(root.left); ``    ``document.write(root.data + ``" "``); ``    ``printInorder(root.right); ``} `` ` `function` `checktree(preorder, inorder, postorder, N){ ``    ``if``(N == 0) ``return` `true``; ``     ` `    ``inorderIndexMap = ``new` `Map(); ``    ``for``(let i = 0; i

Output
```Yes

```

Time Complexity: O(N)
Auxiliary Space: O(N), where N is number of nodes in the tree.

Previous
Next