剑指offer_根据前序和中序确定二叉树

/*
重建二叉树：
根据前序和中序确定二叉树
思路：
递归，找到前序的第一个元素在中序中的位置，该位置之前的元素均为左子树，该位置之后的元素均为右子树，递归处理左右子树
*/
class TreeNode {
      int val;
      TreeNode left;
      TreeNode right;
      TreeNode(int x) { val = x; }
 }
 
public class ReConstructBinaryTree {
    public static TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        
		//判断序列是否为空
		if (pre==null||in==null)
        {
			return null;
        }

		return construct(pre, 0, pre.length-1, in, 0, in.length-1);
	}

		public static TreeNode construct(int[] pre, int preStart, int preEnd, int[] in, int inStart, int inEnd){
			
			//创建根节点
			int rootVal=pre[preStart];
			TreeNode tn=new TreeNode(rootVal);
			tn.left=null;
			tn.right=null;

			//找到跟结点在中序序列中的位置
			int inRootLoc=-1;
			for (int i=0;i<in.length;i++ )
			{
				if (in[i]==rootVal)
				{
					inRootLoc=i;
					break;
				}
			}
			if (inRootLoc==-1)
			{
				System.out.println("非法输入");
				return null;
			}

			//左子树元素个数
			int leftLength=inRootLoc-inStart;

			//左子树前序序列
			int preStart_left=preStart+1;
			int preEnd_left=preStart+leftLength;

			//右子树前序序列
			int preStart_right=preEnd_left+1;
			int preEnd_right=preEnd;
			
			//左子树中序序列
			int inStart_left=inStart;
			int inEnd_left=inRootLoc-1;

			//右子树中序序列
			int inStart_right=inRootLoc+1;
			int inEnd_right=inEnd;

			if (leftLength>0)
			{
				tn.left=construct(pre, preStart_left, preEnd_left, in, inStart_left, inEnd_left);
			}
			if (leftLength<preEnd-preStart)
			{
				tn.right=construct(pre, preStart_right, preEnd_right, in, inStart_right, inEnd_right);
			}

			return tn;
		}

		public static void print(TreeNode tn)
		{
			if (tn!=null)
			{
				System.out.println(tn.val);
				print(tn.left);
				print(tn.right);
			}
		}

		public static void main(String[] args)
		{
			int[] pre={1,2,4,7,3,5,6,8};
			int[] in={4,7,2,1,5,3,8,6};
			
			TreeNode tn=reConstructBinaryTree(pre,in);
			
			print(tn);

		}
}