根据树的后序和中序序列或者前序和中序序列构建二叉树，

（1）根据中序遍历和后序遍历树构造二叉树

 注意事项
你可以假设树中不存在相同数值的节点
样例
给出树的中序遍历： [1,2,3] 和后序遍历： [1,3,2]
返回如下的树：
  2
 /  \

1    3

import java.util.Arrays;
import java.util.Scanner;

/**
 * 根据中序遍历和后序遍历树构造二叉树
 注意事项
你可以假设树中不存在相同数值的节点
样例
给出树的中序遍历： [1,2,3] 和后序遍历： [1,3,2]
返回如下的树：
  2

 /  \

1    3
 * 
 * @author Dell
 *
 */
public class Test72 {
	public static TreeNode buildTree(int[] mid,int[] post) 
    {
   	   if(post.length>0)
   	   {
   		   TreeNode t=new TreeNode(post[post.length-1]);
   		   int index=find(mid,post[post.length-1]);
   		   int[] mid1=Arrays.copyOfRange(mid, 0, index);
   		   int[] post1=Arrays.copyOfRange(post, 0, index);
   		   int[] mid2=Arrays.copyOfRange(mid, 1+index, mid.length);
   		   int[] post2=Arrays.copyOfRange(post,index, post.length-1);
   		   t.left=buildTree(mid1,post1);
   		   t.right=buildTree(mid2,post2);
   		   return t;
   	   }
       return null;
    }
	public static int find(int[] a,int target)
    {      
    	int index=-1;
    	for(int i=0;i<a.length;i++)
    	{
    	    if(a[i]==target)
    	    {	index=i;
    	        break;
    	    }
    	}
    	 return index;
    	
    }
	public static void preorder(TreeNode t)
	{
		if(t!=null)
		{
			System.out.print(t.val+" ");
			preorder(t.left);
			preorder(t.right);
		}
		
	}
	public static void main(String[] args) {
		  Scanner sc=new Scanner(System.in);
		  int n=sc.nextInt();
         int []mid=new int[n];
         int []post=new int[n];
         for(int i=0;i<n;i++)
         {
        	 mid[i]=sc.nextInt();
         }
         for(int i=0;i<n;i++)
         {
        	 post[i]=sc.nextInt();
         }
		 TreeNode t= buildTree(mid,post);
		 preorder(t);
	}

}

（2）根据前序遍历和中序遍历树构造二叉树.

 注意事项
你可以假设树中不存在相同数值的节点
您在真实的面试中是否遇到过这个题？ Yes
样例
给出中序遍历：[1,2,3]和前序遍历：[2,1,3]. 返回如下的树:
  2
 / \
1   3

import java.util.Arrays;
import java.util.Scanner;

/**
 * 
 * 根据前序遍历和中序遍历树构造二叉树.
 注意事项
你可以假设树中不存在相同数值的节点
您在真实的面试中是否遇到过这个题？ Yes
样例
给出中序遍历：[1,2,3]和前序遍历：[2,1,3]. 返回如下的树:

  2
 / \
1   3
 * @author Dell
 *
 */
class TreeNode{
	
	public int val;
	public TreeNode left;
	public TreeNode right;
	public TreeNode(int val)
	{
		this.val=val;
		this.left=this.right=null;
	}
	
}
public class Test73 {
     public static TreeNode buildTree(int[] pre,int[] mid) 
     {
    	   if(pre.length>0)
    	   {
    		   TreeNode t=new TreeNode(pre[0]);
    		   int index=find(mid,pre[0]);
    		   int[] pre1=Arrays.copyOfRange(pre, 1, 1+index);
    		   int[] mid1=Arrays.copyOfRange(mid, 0, index);
    		   int[] pre2=Arrays.copyOfRange(pre, 1+index, pre.length);
    		   int[] mid2=Arrays.copyOfRange(mid, index+1, mid.length);
    		   t.left=buildTree(pre1,mid1);
    		   t.right=buildTree(pre2,mid2);
    		   return t;
    	   }
        return null;
     }
     
    public static int find(int[] a,int target)
    {      
    	int index=-1;
    	for(int i=0;i<a.length;i++)
    	{
    	    if(a[i]==target)
    	    {	index=i;
    	        break;
    	    }
    	}
    	 return index;
    	
    }

	public static void postorder(TreeNode t)
     {
    	 if(t!=null)
    	 {
    		 postorder(t.left);
    		 postorder(t.right);
    		 System.out.print(t.val+" "); 
    	 }
    	 
     }
	public static void main(String[] args) {
		  Scanner sc=new Scanner(System.in);
		  int n=sc.nextInt();
         int []pre=new int[n];
         int []mid=new int[n];
         for(int i=0;i<n;i++)
         {
        	 pre[i]=sc.nextInt();
         }
         for(int i=0;i<n;i++)
         {
        	 mid[i]=sc.nextInt();
         }
		 TreeNode t= buildTree(pre,mid);
		 postorder(t);
	}

}