重建二叉树

1、问题

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

2、方法

*法1（利用下标）

前序遍历的访问顺序是 根->左->右
中序遍历的访问顺序是 左->根->右
要想重建一个二叉树，那么就得知道它的根、左子树、右子树，恰好前序遍历的结果可以说明根，中序遍历的结果可以说明左右子树，知道了左、右子树，那么怎么样将它们表示出来呢？
在中序结果中找到根的索引index，并利用前序遍历preStart、preEnd，中序遍历midStart、midEnd计算出下一次递归的前序、中序起始下标。

/**
 * 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) {
        TreeNode t = reconstruct(0, pre.length-1, 0, in.length-1, pre, in);
        return t;
    }
    private TreeNode reconstruct(int preStart, int preEnd, int midStart, int midEnd, int []pre, int []in){
       int val = pre[preStart];
       TreeNode t = new TreeNode(val);
       t.left = null;
       t.right = null;
       if(preStart==preEnd || midStart==midEnd){
           return t;
       }      
       int index = FindIndex(in, val);
       int leftL = index-midStart;
       int rightL = midEnd - index;
       if(leftL>0)
           t.left = reconstruct(preStart+1, preStart+leftL, midStart, index-1, pre, in);
       if(rightL>0)
            t.right = reconstruct(preStart+leftL+1, preEnd, index+1, midEnd, pre, in);
        return t;
    }
    int FindIndex(int[] arr, int val){
        for(int i=0;i<arr.length;++i){
            if(arr[i]==val)
                return i;
        }
        return -1;
    }
}

时间复杂度为O(n)

分治法时间复杂度求解可以参考：分治法1、分治法2
空间复杂度
因为每次存储1个结点，所以为O(n)。

*法2（较简洁）

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
import java.util.Arrays;
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        if (pre.length == 0 || in.length == 0) {
            return null;
        }
        TreeNode root = new TreeNode(pre[0]);
        // 在中序中找到前序的根
        for (int i = 0; i < in.length; i++) {
            if (in[i] == pre[0]) {
                // 左子树，注意 copyOfRange 函数，左闭右开
                root.left = reConstructBinaryTree(Arrays.copyOfRange(pre, 1, i + 1), Arrays.copyOfRange(in, 0, i));
                // 右子树，注意 copyOfRange 函数，左闭右开
                root.right = reConstructBinaryTree(Arrays.copyOfRange(pre, i + 1, pre.length), Arrays.copyOfRange(in, i + 1, in.length));
                break;
            }
        }
        return root;
    }
}

时间复杂度和空间复杂度同上。