Untitled

public class Solution {
    public TreeNode constructFromPrePost(int[] preorder, int[] postorder) {
        // Map postorder values to their indices for quick lookup
        HashMap<Integer, Integer> postIndexMap = new HashMap<>();
        for (int i = 0; i < postorder.length; i++) {
            postIndexMap.put(postorder[i], i);
        }

        return buildTree(preorder, postorder, 0, preorder.length - 1, 0, postorder.length - 1, postIndexMap);
    }

    private TreeNode buildTree(int[] preorder, int[] postorder, 
                               int preStart, int preEnd, 
                               int postStart, int postEnd, 
                               HashMap<Integer, Integer> postIndexMap) {
        if (preStart > preEnd || postStart > postEnd) {
            return null;
        }

        // The current root is at preStart in preorder
        TreeNode root = new TreeNode(preorder[preStart]);

        // If there's only one node in this subtree, return it
        if (preStart == preEnd) {
            return root;
        }

        // Find the left child in preorder, and locate its index in postorder
        int leftChild = preorder[preStart + 1];
        int leftChildPostIndex = postIndexMap.get(leftChild);

        // Calculate the size of the left subtree
        int leftSubtreeSize = leftChildPostIndex - postStart + 1;

        // Recursively build the left and right subtrees
        root.left = buildTree(preorder, postorder, 
                              preStart + 1, preStart + leftSubtreeSize, 
                              postStart, leftChildPostIndex, 
                              postIndexMap);

        root.right = buildTree(preorder, postorder, 
                               preStart + leftSubtreeSize + 1, preEnd, 
                               leftChildPostIndex + 1, postEnd - 1, 
                               postIndexMap);

        return root;
    }
}