力扣105. 从前序与中序遍历序列构造二叉树

Problem: 105. 从前序与中序遍历序列构造二叉树

题目描述

思路

首先明确：

1.前序遍历的顺序是根-左-右（即先遍历根节点，再左子树，再右子树）
2.中序遍历的顺序是左-右-根

1.前序遍历数组中的第一个元素一定是树的根节点
2.每次在前序数组中找出根节点，再到的中序数组中找出根节点，则在中序数组中该根节点的左侧为根节点的左子树、右侧是根节点的右子树（则我们每次要重复该操作去构造二叉树）

解题方法

1.定义构造二叉树的递归函数TreeNode build(int[] preorder, int preStart, int preEnd, int[] inorder, int inStart, int inEnd)其中preStart是每次递归前序遍历数组中的起始位置preEnd是每次递归前序遍历数组中的结束位置，同理inStart 每次递归中序遍历数组的起始位置inEnd每次递归数组的结束位置
2.定义一个Map<Integer, Integer> valToIndex;在中序遍历数组中每次根节点的索引位置
3.每次递归中先在先序数组中取出当前的父节点再再中序数组中找出当前父节点的索引（index），通过计算得到左子树所有节点的长度：int leftSize = index - inStart;
4.下一次递归的起始与结束位置为preStart + 1, preStart + leftSize,inStart, index - 1,preStart + leftSize + 1，index + 1, inEnd

复杂度

时间复杂度:

$O(n)$；其中$n$为树节点的个数

空间复杂度:

$O(heigh)$；其中$height$为树的高度

Code

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

    /**
     * Construct Binary Tree from Preorder and Inorder Traversal
     *
     * @param preorder First order traversal of the resulting set
     * @param inorder  The set of results obtained by inorder traversal
     * @return TreeNode
     */
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        for (int i = 0; i < inorder.length; ++i) {
            valToIndex.put(inorder[i], i);
        }
        return build(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);
    }

    /**
     * Recursive implementation function
     *
     * @param preorder First order traversal of the resulting set
     * @param preStart The starting position in a sequence of preordinals
     * @param preEnd   The end position in a preordinal group
     * @param inorder  The set of results obtained by inorder traversal
     * @param inStart  The starting position in the ordinal group
     * @param inEnd    End position in an ordinal group
     * @return TreeNode
     */
    TreeNode build(int[] preorder, int preStart, int preEnd, int[] inorder, int inStart, int inEnd) {
        //Base case;
        if (preStart > preEnd) {
            return null;
        }
        int rootVal = preorder[preStart];
        int index = valToIndex.get(rootVal);
        int leftSize = index - inStart;
        // First construct the current root node
        TreeNode root = new TreeNode(rootVal);
        // Recursively construct the left and right subtrees
        root.left = build(preorder, preStart + 1, preStart + leftSize, inorder, inStart, index - 1);
        root.right = build(preorder, preStart + leftSize + 1, preEnd, inorder, index + 1, inEnd);
        return root;
    }
}