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

• Difficulty Level : Medium
• Last Updated : 19 Jul, 2022

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
Explanation : 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:

## C++

 `/* C++ program to check if all three given``   ``traversals are of the same tree */``#include ``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;``}`

## Java

 `/* 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"``);` `}``}`

## Python3

 `# 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`

## C#

 `/* 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 */`

## Javascript

 ``

Output

`Yes`

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

This article is contributed by Harsh Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

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++

 `#include ``using` `namespace` `std;``struct` `Node {``    ``int` `data;``    ``Node *left, *right;` `    ``Node(``int` `val)``    ``{``        ``data = val;``        ``left = right = NULL;``    ``}``};``Node* buildTreeFromInorderPreorder(``    ``int` `inStart, ``int` `inEnd, ``int``& preIndex, ``int` `preorder[],``    ``unordered_map<``int``, ``int``>& inorderIndexMap,``    ``bool``& notPossible)``{``    ``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.find(rootData)``        ``== inorderIndexMap.end()) {``        ``notPossible = ``true``;``        ``return` `root;``    ``}` `    ``int` `inorderIndex = inorderIndexMap[rootData];``    ``if` `(!(inStart <= inorderIndex``          ``&& inorderIndex <= inEnd)) {``        ``notPossible = ``true``;``        ``return` `root;``    ``}` `    ``int` `leftInorderStart = inStart,``        ``leftInorderEnd = inorderIndex - 1,``        ``rightInorderStart = inorderIndex + 1,``        ``rightInorderEnd = inEnd;` `    ``root->left = buildTreeFromInorderPreorder(``        ``leftInorderStart, leftInorderEnd, preIndex,``        ``preorder, inorderIndexMap, notPossible);` `    ``if` `(notPossible)``        ``return` `root;` `    ``root->right = buildTreeFromInorderPreorder(``        ``rightInorderStart, rightInorderEnd, preIndex,``        ``preorder, inorderIndexMap, notPossible);` `    ``return` `root;``}` `bool` `checkPostorderCorrect(Node* root, ``int``& postIndex,``                           ``int` `postorder[])``{``    ``if` `(!root)``        ``return` `true``;` `    ``if` `(!checkPostorderCorrect(root->left, postIndex,``                               ``postorder))``        ``return` `false``;``    ``if` `(!checkPostorderCorrect(root->right, postIndex,``                               ``postorder))``        ``return` `false``;` `    ``return` `(root->data == postorder[postIndex++]);``}` `void` `printPostorder(Node* root)``{``    ``if` `(!root)``        ``return``;` `    ``printPostorder(root->left);``    ``printPostorder(root->right);` `    ``cout << root->data << ``", "``;``}` `void` `printInorder(Node* root)``{``    ``if` `(!root)``        ``return``;` `    ``printInorder(root->left);``    ``cout << root->data << ``", "``;``    ``printInorder(root->right);``}` `bool` `checktree(``int` `preorder[], ``int` `inorder[],``               ``int` `postorder[], ``int` `N)``{``    ``// Your code goes here``    ``if` `(N == 0)``        ``return` `true``;` `    ``unordered_map<``int``, ``int``> inorderIndexMap;``    ``for` `(``int` `i = 0; i < N; i++)``        ``inorderIndexMap[inorder[i]] = i;` `    ``int` `preIndex = 0;` `    ``// return checkInorderPreorder(0, N - 1, preIndex,``    ``// preorder, inorderIndexMap) &&``    ``// checkInorderPostorder(0, N - 1, postIndex, postorder,``    ``// inorderIndexMap);` `    ``bool` `notPossible = ``false``;` `    ``Node* root = buildTreeFromInorderPreorder(``        ``0, N - 1, preIndex, preorder, inorderIndexMap,``        ``notPossible);` `    ``if` `(notPossible)``        ``return` `false``;` `    ``int` `postIndex = 0;` `    ``return` `checkPostorderCorrect(root, postIndex,``                                 ``postorder);``}` `// 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]);` `    ``// If both postorder traversals are same``    ``if` `(checktree(preOrder, inOrder, postOrder, len))``        ``cout << ``"Yes"``;``    ``else``        ``cout << ``"No"``;` `    ``return` `0;``}`

Output

`Yes`

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

My Personal Notes arrow_drop_up