Leetcode【递归】| 105. 从前序与中序遍历序列构造二叉树

题目

根据一棵树的前序遍历与中序遍历构造二叉树。
注意:
你可以假设树中没有重复的元素。
例如，给出
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：
　　3
　 ／＼
　9 　20
　 　 ／＼
　　15　 7
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal

解题

递归

思路：
　前序遍历的递归是：[根节点，[左子树]，[右子树]]
　中序遍历的递归是：[[左子树]，根节点，[右子树]]
　因为根节点的左结点就是左子树当作一个树时的根结点，根节点的右节点时右子树的根节点。所以我们也可以通过递归把各个子树的根节点一个个找出来。

1. 根据前序遍历第一个遍历的时根节点来确认目前的根节点，然后找出中序遍历当前根节点的位置，从而将根节点的左子树和右子树的所有结点分离出来（中序遍历当前根节点左边的就是左子树的所有结点，右边的就是右子树的所有节点）
2. 然后将左子树和右子树进行递归，分别求出左子树和右子树的根节点，分别为当前根节点的左结点和右节点。
3. 递归终止条件：当前根节点已经没有左/右子树/结点，返回null结点。

相当于将树的遍历的递归反过来：

1. 二叉树的遍历的递归是每一次将遍历到的该结点当作根节点，递归方法传递该根节点，将其左右结点分别按顺序继续当作根节点递归一个个输出。
2. 该题是根据遍历的顺序结果，根据前序遍历每次将第一个根节点求出，再根据中序遍历将根节点的左子树、右子树的结点的中序遍历分离出，每次递归返回该树的根节点。
   根节点的左结点 = 其左子树的根节点，即递归(左子树中序遍历结果)；
   根节点的右节点 = 其右子树的根节点，即递归(右子树中序遍历结果)
   参考题解：递归构造树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int i = 0;//根节点在前序遍历中的下标，初始为第一个
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        //找根节点，用中序遍历 区分出左子树和右子树 然后分别将其当成单独的树再递归
        return create(preorder,inorder,0,inorder.length-1);//将该树的前序、中序遍历和  子树在中序遍历的下标区间作为变量传输递归
    }
    public TreeNode create(int[] preorder, int[] inorder, int left, int right){
        //递归的最小子条件，已经没有子树/结点了，所以子树在中序遍历中的位置left=j+1会大于right
        if(left>right) return null;

        //从左范围出发，根据前序遍历中根节点的位置i从中序遍历中找出根节点所在位置的下标j
        int j = left;
        while(j<=right&&preorder[i] != inorder[j]){
            j++;
        }
        //构造当前树，root为当前preorder[i], 左子树和右子树分别进行递归构造，当前root的左结点是其左子树的根节点，右节点是当前右子树的根节点，树的根节点更新
        TreeNode root = new TreeNode(preorder[i]);
        i++;
        //构造左子树，当前中序遍历[left,right]中根节点j左边的结点
        root.left = create(preorder,inorder,left,j-1);
        //构造右子树，当前中序遍历[left,right]中根节点j右边的结点
        root.right = create(preorder,inorder,j+1,right);
        return root;

    }
}

优化：将中序遍历顺序用哈希表来存储，这样搜索中序遍历的根节点的位置时更快，优化了时间，参考官方题解

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    private Map<Integer, Integer> indexMap;

    public TreeNode myBuildTree(int[] preorder, int[] inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right) {
        if (preorder_left > preorder_right) {
            return null;
        }

        // 前序遍历中的第一个节点就是根节点
        int preorder_root = preorder_left;
        // 在中序遍历中定位根节点
        int inorder_root = indexMap.get(preorder[preorder_root]);
        
        // 先把根节点建立出来
        TreeNode root = new TreeNode(preorder[preorder_root]);
        // 得到左子树中的节点数目
        int size_left_subtree = inorder_root - inorder_left;
        // 递归地构造左子树，并连接到根节点
        // 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
        root.left = myBuildTree(preorder, inorder, preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1);
        // 递归地构造右子树，并连接到根节点
        // 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
        root.right = myBuildTree(preorder, inorder, preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right);
        return root;
    }

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int n = preorder.length;
        // 构造哈希映射，帮助我们快速定位根节点
        indexMap = new HashMap<Integer, Integer>();
        for (int i = 0; i < n; i++) {
            indexMap.put(inorder[i], i);
        }
        return myBuildTree(preorder, inorder, 0, n - 1, 0, n - 1);
    }
}