105. 从前序与中序遍历序列构造二叉树——中等

一、题目

根据一棵树的前序遍历与中序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，给出

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

    3
   / \
  9  20
    /  \
   15   7

二、思路

对于任意一颗树而言，前序遍历的形式总是

[ 根节点, [左子树的前序遍历结果], [右子树的前序遍历结果] ]

即根节点总是前序遍历中的第一个节点。而中序遍历的形式总是

[ [左子树的中序遍历结果], 根节点, [右子树的中序遍历结果] ]

• 只要我们在中序遍历中定位到根节点，那么我们就可以分别知道左子树和右子树中的节点数目。
• 由于同一颗子树的前序遍历和中序遍历的长度显然是相同的，因此我们就可以对应到前序遍历的结果中，对上述形式中的所有左右括号进行定位。

这样以来，我们就知道了左子树的前序遍历和中序遍历结果，以及右子树的前序遍历和中序遍历结果，我们就可以递归地对构造出左子树和右子树，再将这两颗子树接到根节点的左右位置。

如上图：

1. preLeft、preLeft+1、preRight、inLeft、inRight都可以又提供的数组求出
2. pIndex根据preLeft，在Map中取出
3. 由于 前序遍历的左子树的节点数 = 中序遍历的左子树的节点数
   所以pIndex - 1 - inLeft = x - (preLeft + 1) ,求出x = pIndex - inLeft + preLeft

三、代码

public class LeetCode_105 {

    public static void main(String[] args) {
    }

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int preLen = preorder.length;
        int inLen = inorder.length;

        if (preLen != inLen) {
            throw new RuntimeException("输入的数据不一致");
        }
        // 使用Map存储中序遍历的节点，方便快速定位根节点
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < inLen; i++) {
            map.put(inorder[i],i);
        }
        return buildTree(preorder, 0, preLen - 1, map, 0, inLen - 1);
    }

    private TreeNode buildTree(int[] preorder, int preLeft, int preRight, Map<Integer, Integer> map, int inLeft, int inRight) {
        if(preLeft > preRight || inLeft > inRight){
            return null;
        }
        // 前序遍历中的第一个节点就是根节点
        int rootVal = preorder[preLeft];
        TreeNode root = new TreeNode(rootVal);
        // 在中序遍历中定位根节点
        int pIndex = map.get(rootVal);
        // 递归地构造左子树，并连接到根节点
        root.left = buildTree(preorder,preLeft + 1, pIndex - inLeft + preLeft, map, inLeft, pIndex - 1);
        // 递归地构造右子树，并连接到根节点
        root.right = buildTree(preorder, pIndex - inLeft + preLeft + 1, preRight, map, pIndex + 1, inRight);
        return root;
    }


}

四、复杂度

• 时间复杂度：O(n)，其中 n 是树中的节点个数。

• 空间复杂度：O(n)，除去返回的答案需要的 O(n) 空间之外，我们还需要使用 O(n) 的空间存储哈希映射，以及 O(h)（其中 h 是树的高度）的空间表示递归时栈空间。这里 h<n，所以总空间复杂度为 O(n)。