leetcode算法优化记录：重建二叉树

重建二叉树

基本思路：

运用递归的想法，将先序遍历数组的第一个数字作为当前root节点的值val，接着在中序遍历数组中找到该root.val对应的下标，根据该下标将两个数组分为左子树leftTree和右子树rightTree，最后分别对左右子树进行递归。

基本思路代码：

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder.length == 0 || inorder.length == 0){
            return null;
        }
        int medium_index = 0;  //记录在中序遍历数组中root.val对应的下标
        int rootVal = preorder[0];
        for(int temp_1: inorder){
            if(temp_1 == rootVal){
                break;
            }
            medium_index ++;
        }
        TreeNode presentNode = new TreeNode(rootVal);
        int[] leftMediumArray = new int[medium_index];
        int[] rightMediumArray = new int[inorder.length-medium_index-1];
        if(leftMediumArray.length != 0){
            System.arraycopy(inorder, 0, leftMediumArray, 0, medium_index);
            int[] newPreArray_left = new int[leftMediumArray.length];
            System.arraycopy(preorder, 1, newPreArray_left, 0, leftMediumArray.length);
            presentNode.left = buildTree(newPreArray_left, leftMediumArray);
        }

        if(rightMediumArray.length != 0){
            System.arraycopy(inorder, medium_index+1, rightMediumArray, 0,
                    inorder.length-medium_index-1);
            int[] newPreArray_right = new int[rightMediumArray.length];
            System.arraycopy(preorder, medium_index+1, newPreArray_right, 0, rightMediumArray.length);
            presentNode.right = buildTree(newPreArray_right, rightMediumArray);
        }
        return presentNode;

    }
}

优化分析一：

1、每次递归，都需要用一个循环来寻找root.val对应的下标，浪费时间。替代方案可采取hash表来记录中序遍历数组中数与下标index的对应关系，从而用空间换取时间；
2、每次迭代都要新建左子树和右子树数组，并执行arraycopy，浪费时间和空间。替代方案可以采取启用Integer整型数据作为buildTree方法的形参，代表当前数组的起止索引，从而不用新建和拷贝数组。

优化代码一：

public TreeNode buildTree(int[] preorder, int[] inorder){
        if(preorder.length == 0){
            return null;
        }
        HashMap<Integer, Integer> map = new HashMap<>(inorder.length);
        for(int i = 0; i<inorder.length; i++){
            map.put(inorder[i], i);
        }
        return buildTree(preorder, 0, preorder.length-1, inorder, 0, inorder.length-1, map);
    }
public TreeNode buildTree(int[] preorder, int pl, int pr, int[] inorder, int il, int ir, HashMap<Integer, Integer> map){
        if(pl > pr){
            return null;
        }
        TreeNode presentNode = new TreeNode(preorder[pl]);
        int index = map.get(presentNode.val);
        int num_left = index-il;
        presentNode.left = buildTree(preorder, pl+1, pl+num_left, inorder, il, index-1, map);
        presentNode.right = buildTree(preorder, pl+num_left+1, pr, inorder, index+1, ir, map);
        return presentNode;
    }