138 lines
3.8 KiB
Java
138 lines
3.8 KiB
Java
/** Author : Suraj Kumar
|
||
* Github : https://github.com/skmodi649
|
||
*/
|
||
|
||
|
||
|
||
/** PROBLEM DESCRIPTION :
|
||
* Given Preorder, Inorder and Postorder traversals of some tree of size N.
|
||
* The task is to check if they are all of the same tree or not
|
||
*/
|
||
|
||
|
||
|
||
/** ALGORITHM :
|
||
* The root element will be the first element of preorder.
|
||
* Search for root in the inorder array and store it’s index as idx.
|
||
* Use this idx to determine elements of left and right subtree in all three traversal arrays.
|
||
* Call function recursively for both left and right sub tree.
|
||
*/
|
||
|
||
|
||
|
||
|
||
import java.lang.*;
|
||
import java.util.*;
|
||
|
||
class Tree{
|
||
int val;
|
||
Tree left, right;
|
||
Tree(int val){
|
||
this.val = val;
|
||
left = null; right = null;
|
||
}
|
||
}
|
||
|
||
class Main{
|
||
static int idx;
|
||
static boolean isPossible;
|
||
|
||
public boolean checktree(int[] preorder, int[] inorder, int[] postorder, int N){
|
||
idx = 0;
|
||
isPossible = true;
|
||
Map<Integer, Integer> hmap = new HashMap<>();
|
||
for(int i = 0; i < inorder.length; i++) hmap.put(inorder[i], i);
|
||
Tree root = buildTree(inorder, preorder, hmap, 0, N-1);
|
||
if(!isPossible) return false;
|
||
List<Integer> post = new ArrayList<>();
|
||
buildPost(root, post);
|
||
|
||
return Arrays.equals(post.stream().mapToInt(i->i).toArray(), postorder);
|
||
}
|
||
|
||
private static void buildPost(Tree root, List<Integer> post){
|
||
if(root == null) return;
|
||
buildPost(root.left, post);
|
||
buildPost(root.right, post);
|
||
post.add(root.val);
|
||
}
|
||
|
||
private static Tree buildTree(int[] inorder, int[] preorder, Map<Integer, Integer> hmap, int start, int end){
|
||
if(start > end) return null;
|
||
if(!isPossible) return null;
|
||
int val = preorder[idx++];
|
||
Tree root = new Tree(val);
|
||
if(!hmap.containsKey(val)){
|
||
isPossible = false;
|
||
return null;
|
||
}
|
||
int pos = hmap.get(val);
|
||
if(pos < start || pos > end){
|
||
isPossible = false;
|
||
return null;
|
||
}
|
||
root.left = buildTree(inorder, preorder, hmap, start, pos-1);
|
||
root.right = buildTree(inorder, preorder, hmap, pos+1, end);
|
||
return root;
|
||
}
|
||
|
||
public static void main(String args[])
|
||
{
|
||
Scanner sc = new Scanner(System.in);
|
||
System.out.print("Enter the value of N : ");
|
||
int n = sc.nextInt();
|
||
int[] preorder = new int[n];
|
||
int[] inorder = new int[n];
|
||
int[] postorder = new int[n];
|
||
System.out.println("Enter the elements of preorder array : ");
|
||
for(int i=0; i<n; i++)
|
||
preorder[i] = sc.nextInt();
|
||
System.out.println("Enter the elements of inorder array : ");
|
||
for(int i=0; i<n; i++)
|
||
inorder[i] = sc.nextInt();
|
||
System.out.println("Enter the elements of postorder array : ");
|
||
for(int i=0; i<n; i++)
|
||
postorder[i] = sc.nextInt();
|
||
Main ob = new Main();
|
||
if(ob.checktree(preorder, inorder, postorder, n) )
|
||
System.out.println("Yes");
|
||
else
|
||
System.out.println("No");
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/** TEST CASES :
|
||
* Test Case 1 :
|
||
* Input : N = 5 , preorder[] = {1, 2, 4, 5, 3} , inorder[] = {4, 2, 5, 1, 3} and postorder[] = {4, 5, 2, 3, 1}
|
||
* Output : Yes
|
||
*
|
||
* Test Case 2 :
|
||
* Input : N = 5 , preorder[] = {1, 5, 4, 2, 3} , inorder[] = {4, 2, 5, 1, 3} and postorder[] = {4, 1, 2, 3, 5}
|
||
* Output : No
|
||
*/
|
||
|
||
|
||
|
||
/** Explanation for Test Case 1 :
|
||
* All the three traversals
|
||
* are of the same tree.
|
||
* 1
|
||
* / \
|
||
* 2 3
|
||
* / \
|
||
* 4 5
|
||
* hence the output is Yes
|
||
*/
|
||
|
||
|
||
/** Time Complexity : O(N^2)
|
||
* Auxiliary Space Complexity : O(N)
|
||
* Constraints : 1 ≤ N ≤ 103
|
||
* Node values are unique.
|
||
*/
|
||
|
||
|
||
|