Build Binary Tree from Preorder and Inorder Traversal

class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        unordered_map<int,int> idx;
        for (int i = 0; i < (int)inorder.size(); ++i) idx[inorder[i]] = i;
        int p = 0;
        function<TreeNode*(int,int)> build = [&](int lo, int hi) -> TreeNode* {
            if (lo > hi) return nullptr;
            int v = preorder[p++];
            TreeNode* node = new TreeNode(v);
            int m = idx[v];
            node->left = build(lo, m - 1);
            node->right = build(m + 1, hi);
            return node;
        };
        return build(0, inorder.size() - 1);
    }
};

func buildTree(preorder []int, inorder []int) *TreeNode {
    idx := make(map[int]int, len(inorder))
    for i, v := range inorder {
        idx[v] = i
    }
    p := 0
    var build func(lo, hi int) *TreeNode
    build = func(lo, hi int) *TreeNode {
        if lo > hi {
            return nil
        }
        v := preorder[p]
        p++
        node := &TreeNode{Val: v}
        m := idx[v]
        node.Left = build(lo, m-1)
        node.Right = build(m+1, hi)
        return node
    }
    return build(0, len(inorder)-1)
}

from typing import List, Optional

# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
        idx = {v: i for i, v in enumerate(inorder)}
        self.p = 0
        def build(lo: int, hi: int) -> Optional[TreeNode]:
            if lo > hi:
                return None
            v = preorder[self.p]
            self.p += 1
            node = TreeNode(v)
            m = idx[v]
            node.left = build(lo, m - 1)
            node.right = build(m + 1, hi)
            return node
        return build(0, len(inorder) - 1)

function buildTree(preorder, inorder) {
    const idx = new Map();
    for (let i = 0; i < inorder.length; i++) idx.set(inorder[i], i);
    let p = 0;
    const build = (lo, hi) => {
        if (lo > hi) return null;
        const v = preorder[p++];
        const node = new TreeNode(v);
        const m = idx.get(v);
        node.left = build(lo, m - 1);
        node.right = build(m + 1, hi);
        return node;
    };
    return build(0, inorder.length - 1);
}

class Solution {
    private int[] preorder;
    private Map<Integer, Integer> idx = new HashMap<>();
    private int p = 0;

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        this.preorder = preorder;
        for (int i = 0; i < inorder.length; i++) idx.put(inorder[i], i);
        return build(0, inorder.length - 1);
    }

    private TreeNode build(int lo, int hi) {
        if (lo > hi) return null;
        int v = preorder[p++];
        TreeNode node = new TreeNode(v);
        int m = idx.get(v);
        node.left = build(lo, m - 1);
        node.right = build(m + 1, hi);
        return node;
    }
}

function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
    const idx = new Map<number, number>();
    for (let i = 0; i < inorder.length; i++) idx.set(inorder[i], i);
    let p = 0;
    const build = (lo: number, hi: number): TreeNode | null => {
        if (lo > hi) return null;
        const v = preorder[p++];
        const node = new TreeNode(v);
        const m = idx.get(v)!;
        node.left = build(lo, m - 1);
        node.right = build(m + 1, hi);
        return node;
    };
    return build(0, inorder.length - 1);
}