Through middle order traversal and pre order traversal, the subsequent traversal will always build a binary tree

Construct binary tree through preorder traversal and inorder traversal
Use the root node and the first left node traversed in the middle order to obtain the node length , Right node subscript .
Traverse through the preamble ( First node ) And subsequent traversal ( The last node ) Get the root node

    public class TreeNode {
    
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int x) {
    
            val = x;
        }
    }

    /** *  Construct binary tree through preorder traversal and inorder traversal , Premise tree node values are not repeated  * * @param pre  The result of preorder traversal  * @param preRootNodeStart  The preamble traversal starts with the subscript of the root node  * @param preEnd  The last subscript of the preorder traversal set  * @param inLeftNodeStart  The middle order traverses the first left node subscript  * @param inPos  Mapping relationship between middle order traversal value and subscript  * @return */
    private TreeNode buildTree(int[] pre, int preRootNodeStart, int preEnd, int inLeftNodeStart, Map<Integer, Integer> inPos) {
    
        if (preRootNodeStart > preEnd) return null;
        TreeNode root = new TreeNode(pre[preRootNodeStart]);
        //  Get the subscript of the root node traversal in the middle order 
        int rootIdx = inPos.get(pre[preRootNodeStart]);
        //  Get the length of the left subtree 
        int leftLen = rootIdx - inLeftNodeStart;
        root.left = buildTree(pre, preRootNodeStart + 1, preRootNodeStart + leftLen, inLeftNodeStart, inPos);
        root.right = buildTree(pre, preRootNodeStart + leftLen + 1, preEnd, rootIdx + 1, inPos);
        return root;
    }

    public TreeNode buildTree(int[] pre, int[] in) {
    
        Map<Integer, Integer> inPos = new HashMap<>();
        for (int i = 0; i < in.length; i++) {
    
            inPos.put(in[i], i);
        }
        return buildTree(pre, 0, pre.length - 1, 0, inPos);
    }
	    private TreeNode buildTreePrePostArray(int[] post, int postStart, int postEnd, int inStart, Map<Integer, Integer> inPos) {
    
        if (postStart > postEnd) return null;
        TreeNode root = new TreeNode(post[postEnd]);
        int rootIdx = inPos.get(post[postEnd]);
        int leftLen = rootIdx - inStart;
        root.left = buildTreePrePostArray(post, postStart, postStart + leftLen - 1, inStart, inPos);
        root.right = buildTreePrePostArray(post, postStart +leftLen, postEnd - 1, rootIdx + 1, inPos);
        return root;
    }

    // Time: O(n). Space:O(n)
    public TreeNode buildTreePrePostArray(int[] in, int[] post) {
    
        Map<Integer, Integer> inPos = new HashMap<>();
        for (int i = 0; i < in.length; i++) {
    
            inPos.put(in[i], i);
        }
        return buildTreePrePostArray(post, 0, post.length - 1, 0, inPos);
    }