输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

前序遍历：根节点->左子树->右子树

中序遍历：左子树->根节点->右子树

后序遍历：左子树->右子树->根节点

public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}

import java.util.ArrayList;
import java.util.List;

public class lesson4 {
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 treeNode = reConstructBinaryTree(pre,in);
printTreeNode(treeNode);
}
private static void printTreeNode(TreeNode treeNode) {
if(treeNode != null){
System.out.print(treeNode.val + " ");
TreeNode left = treeNode.left;
printTreeNode(left);
TreeNode right = treeNode.right;
printTreeNode(right);
}
}
public static TreeNode reConstructBinaryTree(int [] pre,int [] in) {
print(pre, in);
TreeNode root = null;
if(pre != null && pre.length > 0){
root = new TreeNode(pre[0]);
}
//根据中序，找到左边的数组
if(in != null && in.length > 0){
List<Integer> inLeftList = new ArrayList();
List<Integer> inRightList = new ArrayList();
//分解后序遍历数组
int[] inLeftChild = null, inRightChild = null;
boolean find = false;
for(int i = 0; i < in.length; i ++){
if(in[i] == pre[0]){//找到了
find = true;
}else if(!find){
inLeftList.add(in[i]);
}else if(find){
inRightList.add(in[i]);
}
}
inLeftChild = getIntArray(inLeftList);
inRightChild = getIntArray(inRightList);
//分解前序遍历数组
int[] preLeftChild = null, preRightChild = null;
int leftCount = 0, rightCount = 0;
if(inLeftChild != null && inLeftChild.length > 0){
leftCount = inLeftChild.length;
if(preLeftChild == null){
preLeftChild = new int[leftCount];
}
}
if(inRightChild != null && inRightChild.length > 0){
rightCount = inRightChild.length;
if(preRightChild == null){
preRightChild = new int[rightCount];
}
}
for(int i = 1; i < pre.length; i ++){
int value = pre[i];
if(i <= leftCount){
preLeftChild[i - 1] = value;
}else if(i >= leftCount + 1  && i <= leftCount + rightCount){
preRightChild[i - leftCount - 1] = value;
}
}
root.left = reConstructBinaryTree(preLeftChild, inLeftChild);
root.right = reConstructBinaryTree(preRightChild, inRightChild);
}
return root;
}

private static void print(int[] pre, int[] in) {
if(pre == null && in == null)return;
// TODO Auto-generated method stub
System.out.print("pre ");
if(pre != null && pre.length > 0){
for(int i = 0; i < pre.length; i ++){
System.out.print(pre[i] + " ");
}
}
System.out.print(" in ");
if(in != null && in.length > 0){
for(int i = 0; i < in.length; i ++){
System.out.print(in[i] + " ");
}
}
System.out.println("");
System.out.println("-----------------------------------------");
}
private static int[] getIntArray(List<Integer> list) {
// TODO Auto-generated method stub
if(list != null && list.size() > 0){
int[] array = new int[list.size()];
for(int i = 0; i < list.size(); i++){
array[i] = list.get(i);
}
return array;
}
return null;
}
}

pre 1 2 4 7 3 5 6 8  in 4 7 2 1 5 3 8 6
-----------------------------------------
pre 2 4 7  in 4 7 2
-----------------------------------------
pre 4 7  in 4 7
-----------------------------------------
pre 7  in 7
-----------------------------------------
pre 3 5 6 8  in 5 3 8 6
-----------------------------------------
pre 5  in 5
-----------------------------------------
pre 6 8  in 8 6
-----------------------------------------
pre 8  in 8
-----------------------------------------
1 2 4 7 3 5 6 8