剑指Offer-7. 重建二叉树

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

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {

        if (pre == null 
            || in == null 
            || pre.length <= 0) return null;

        int len = pre.length;

        return ConstructCore(pre, 0, len - 1, in, 0, len - 1);
    }

    public TreeNode ConstructCore(int[] pre,
                             int preStartIndex,
                             int preEndIndex,
                             int[] in,
                             int inStartIndex,
                             int inEndIndex) {

        // 从前序中找到根结点，并构建根结点
        int rootVal = pre[preStartIndex];
        TreeNode root = new TreeNode(rootVal);

        // 考虑只有一个元素的情况
        if (preStartIndex == preEndIndex) {
            if (inStartIndex == inEndIndex
               && inStartIndex == preStartIndex)
                return root;
        }

        // 在中序中定位到根结点的位置
        int rootInIndex = inStartIndex;
        while (rootInIndex <= inEndIndex
              && in[rootInIndex] != rootVal) rootInIndex++;

        // 计算左子树的元素个数
        int leftLen = rootInIndex - inStartIndex;
        // 找到左子树在前序中结束的位置
        int leftPreEnd = preStartIndex + leftLen;

        // 构建左子树
        if (leftLen > 0) {
            root.left = ConstructCore(pre,
                                     preStartIndex + 1,
                                     leftPreEnd,
                                     in,
                                     inStartIndex,
                                     rootInIndex - 1);
        }

        // 如果还有右子树，继续构建
        if (leftLen < preEndIndex - preStartIndex) {
            root.right = ConstructCore(pre,
                                      leftPreEnd + 1,
                                      preEndIndex,
                                      in,
                                      rootInIndex + 1, inEndIndex);
        }

        return root;
    }
}