重新构建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
思路：
1. 先序的第一个节点一定是根节点，这样我们就知道了根节点是1.
2. 再看中序， 在中序串之中，根结点的前边的所有节点都是左子树中,所以1节点前面的4,7,2就是左子树的中序遍历序列
3. 再看前序遍历序列 1,2,4,7,3,5,6,8， 由于左子树的节点是4,7,2，我们可以得到左子树的前序遍历序列为: 2,4,7。有了左子树的前序串2,4,7和中序串4,7,2。 我们就可以递归的把左子树给建立起来。
4. 同样，可以建立起右子树。

public class ReBinaryTree {
    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        public TreeNode(){}
        public TreeNode(int x) {
            val = x;
        }
      }
    public static TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        if(pre == null || in == null)
            return null;
        TreeNode tree = reConstruct(pre, in, 0, pre.length - 1, 0, in.length - 1);
        return tree;
    }
    // 递归
    public static TreeNode reConstruct(int [] pre,int [] in, int prest, int preend, int inst, int inend) {
        TreeNode root = new TreeNode(pre[prest]);
        root.left = null;
        root.right = null;
        if (prest == preend && inst == inend) {
            return root;
        }
        int mid = 0;
        for (mid = inst; mid < inend; mid++) {
            if(in[mid] == pre[prest])
                break;
        }
        int leftlen = mid - inst;  // 左子树长度
        int rightlen = inend - mid;  // 右子树长度
        if(leftlen > 0)
            root.left = reConstruct(pre, in, prest + 1, prest + leftlen, inst, mid - 1); //构建左子树
        if(rightlen > 0)
            root.right = reConstruct(pre, in, prest + leftlen + 1, preend, mid + 1, inend); //构建右子树
        return root;

    }
    //将二叉树先序遍历，用于测试结果
    public static void preTraverseBinTree(TreeNode node){
        if (node==null) {
              return;
          }
        System.out.print(node.val+",");
        if (node.left!=null) {
            preTraverseBinTree(node.left);
          }
        if(node.right!=null){
            preTraverseBinTree(node.right);
        }
      }
    //将二叉树中序遍历，用于测试结果
    public static void inTraverseBinTree(TreeNode node){
        if (node==null) {
              return;
          }
        if (node.left!=null) {
            inTraverseBinTree(node.left);
          }
        System.out.print(node.val+",");
        if(node.right!=null){
            inTraverseBinTree(node.right);
        }
      }
  //将二叉树后序遍历，用于测试结果
    public static void postTraverseBinTree(TreeNode node){
        if (node==null) {
              return;
          }
        if (node.left!=null) {
            postTraverseBinTree(node.left);
          }
        if(node.right!=null){
            postTraverseBinTree(node.right);
        }
        System.out.print(node.val+",");
      }
      //主函数，用于测试结果
   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 tree = reConstructBinaryTree(pre, in);
        System.out.print("先序遍历结果:  {");
        preTraverseBinTree(tree);
        System.out.println("}");
        System.out.print("中序遍历结果:  {");
        inTraverseBinTree(tree);
        System.out.println("}");
        System.out.print("后序遍历结果:  {");
        postTraverseBinTree(tree);
        System.out.println("}");
      }
}