[力扣] 剑指 Offer 07. 重建二叉树-----Java

题目：剑指 Offer 07. 重建二叉树

例子：

preorder = [3,9,20,15,7]

inorder = [9,3,15,20,7]

分析：

1.我们知道前序遍历，那么前序遍历的第一个数一定是根结点，也就是 3 一定是根结点

2.我们可以找到中序遍历中，根所在的位置，那么中序遍历中，根前面的数就是左子树结点个数，根后面的就是右子树结点个数，也就是左子树：9；右子树：20、15、7

3.那么左子树的前序 【9】；中序【9】

        右子树的前序：【20、15、7】；右子树的中序：【15、20、7】

4.使用相同的方法，处理规模更小的两个树

5.序列长度在减少，收敛到长度变成0，也就是 前序【】中序【】，那么这就是一个空树

小练一下：

前序：A B D E H C F G

中序：D B E H A F C G

试着还原一下这个二叉树

 步骤：

1.题目传入的是int类型的数组，为了方便我们写代码，我们把int[ ] 变成 List<Integer>

这里我们可以写一个方法来实现

2. 刚才的推导过程需要用递归来实现

递归中：1.先处理特殊情况，也就是前序和中序的长度为0时，实际上就是传入了一个空树

               2.根据前序得到根的值，放在最开始

               3.中序中找到根的位置，得到下标，就是左子树的结点个数

               4.切割出左子树前序和中序，右子树的前序和中序

                左子树一定是从【1】开始，因为根是【0】，右子树从 【1 + 左子树的结点个数】开始

                同理，右子树也是如此

                如图是切割左子树的前序和中序：

                5.同样的方式，构建左右子树，处理过程中，序列长度不断减小，直到为0

               6.构建自己的根，把左右子树联系起来

               7.最后返回自己构建的根

 代码：

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

public class Solution {
    // int数组转成list
    private List<Integer> arrayToList(int[] array){
        List<Integer> list = new ArrayList<>();
        for(int e : array){
            list.add(e);
        }
        return list;
    }

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        // int[] -> List<Integer>
        List<Integer> preorderList = arrayToList(preorder);
        List<Integer> inorderList = arrayToList(inorder);

        // 使用递归
        return buildTree2(preorderList,inorderList);
    }

    // 实现递归
    private TreeNode buildTree2(List<Integer> preorder,List<Integer> inorder){
        // 特殊情况：序列长度为0
        if(preorder.size() == 0){
            return null;
        }
        // 根据前序得到根的值，放在最开始
        int rootVal = preorder.get(0);

        // 左子树的结点个数
        int leftSize = inorder.indexOf(rootVal);

        // 分别切割出左子树的前序 和 中序
        List<Integer> leftPreorder = preorder.subList(1,1 + leftSize);
        List<Integer> leftInorder = inorder.subList(0,leftSize);

        // 切割出右子树的前序 和 中序
        List<Integer> rightPreorder = preorder.subList(1 + leftSize,preorder.size());
        List<Integer> rightInorder = inorder.subList(leftSize + 1,inorder.size());

        // 按照同样的方式，先去构建左右子树
        TreeNode left = buildTree2(leftPreorder,leftInorder);
        TreeNode right = buildTree2(rightPreorder,rightInorder);
        
        // 构建自己的根 把根和左右子树的根结点关联起来
        TreeNode root = new TreeNode(rootVal);
        root.left = left;
        root.right = right;
        
        // 返回构建的二叉树的根
        return root;
    }
}