07. 重建二叉树

重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：

3

/
9 20
/
15 7

限制：
0 <= 节点个数 <= 5000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/zhong-jian-er-cha-shu-lcof

解题思路

1、前序遍历顺序：根节点>左节点>右节点；中序遍历顺序：左节点>根节点>右节点；
2、通过前序遍历数组找到根节点，通过中序遍历数组可知道，其左、右子树，根节点左边即为左子树，右边为右子树；
3、重复步骤2（递归）。

代码1

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        TreeNode node = new TreeNode();
        if(preorder == null || preorder.length == 0) return node;
        int length = preorder.length;
        method(node,0,preorder,inorder,0,length-1);
        return node;

    }
    //flag:用于标记已建好几个节点；preorderArr:前序遍历数组；inOrderArr：中序遍历数组；preIndex：中序遍历数组开始索引；postIndex：中序遍历数组结束索引
    public void method(TreeNode node, Integer flag,int[] preorderArr,int[] inOrderArr,int preIndex,int postIndex){
        if(flag == preorderArr.length || preIndex>postIndex) return;
        int rootIndex = 0;
        for(int i=preIndex;i<postIndex+1;i++){
            //找到根节点索引，在数组中，根节点左边的是根节点左子树，右边的是根节点右子树
            if(preorderArr[flag] == inOrderArr[i]){
                rootIndex = i;
                node.val = preorderArr[flag];
                flag++;
                break;
            }
        }
        //有左子树
        if(rootIndex >= preIndex+1){
            //递归
            node.left = new TreeNode();
            method(node.left,flag,preorderArr, inOrderArr,preIndex,rootIndex-1);
        }

        //有右子树
        if(rootIndex+1 <= postIndex){
            //递归
            node.right = new TreeNode();
            method(node.right,flag,preorderArr, inOrderArr,rootIndex+1,postIndex);
        }
    }
}

报错了：java.lang.StackOverflowError
报错原因：由于深度递归，抛出此错误以指示应用程序的堆栈已耗尽。
解决方案？？？？？望各位大佬指正
I’m terrible~加油加油

接下来是官方题解

代码2

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if (preorder == null || preorder.length == 0) {
            return null;
        }
        Map<Integer, Integer> indexMap = new HashMap<Integer, Integer>();
        int length = preorder.length;
        for (int i = 0; i < length; i++) {
            indexMap.put(inorder[i], i);
        }
        TreeNode root = buildTree(preorder, 0, length - 1, inorder, 0, length - 1, indexMap);
        return root;
    }

    public TreeNode buildTree(int[] preorder, int preorderStart, int preorderEnd, int[] inorder, int inorderStart, int inorderEnd, Map<Integer, Integer> indexMap) {
        if (preorderStart > preorderEnd) {
            return null;
        }
        int rootVal = preorder[preorderStart];
        TreeNode root = new TreeNode(rootVal);
        if (preorderStart == preorderEnd) {
            return root;
        } else {
            int rootIndex = indexMap.get(rootVal);
            int leftNodes = rootIndex - inorderStart, rightNodes = inorderEnd - rootIndex;
            TreeNode leftSubtree = buildTree(preorder, preorderStart + 1, preorderStart + leftNodes, inorder, inorderStart, rootIndex - 1, indexMap);
            TreeNode rightSubtree = buildTree(preorder, preorderEnd - rightNodes + 1, preorderEnd, inorder, rootIndex + 1, inorderEnd, indexMap);
            root.left = leftSubtree;
            root.right = rightSubtree;
            return root;
        }
    }
}
作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/zhong-jian-er-cha-shu-lcof/solution/mian-shi-ti-07-zhong-jian-er-cha-shu-by-leetcode-s/
来源：力扣（LeetCode）