Construct a Tree from Level-Order and Inorder Traversals

Given the levelOrder and inorder traversals of the same binary tree, reconstruct and return its root.
All node values are distinct. Both arrays contain the same values, and together they describe exactly one valid binary tree.

Function
buildTree(levelOrder: int[], inorder: int[]) → TreeNode

Examples
Example 1
levelOrder = [3,9,20,15,7]
inorder = [9,3,15,20,7]
return = [3,9,20,null,null,15,7]
The root 3 appears first in level order; the inorder split places 9 left and the remaining nodes right.
Example 2
levelOrder = [1]
inorder = [1]
return = [1]
Both traversals describe a one-node tree.
Example 3
levelOrder = [1,2,3,4,5]
inorder = [4,2,5,1,3]
return = [1,2,3,4,5]
The traversals reconstruct the shown complete upper levels.

Constraints
1 <= levelOrder.length == inorder.length <= 1200.
-10^9 <= levelOrder[i], inorder[i] <= 10^9.
Each traversal contains distinct values, and both contain the same set of values.
The arrays are valid traversals of one binary tree.

The trick: the first element of level order is always the root. Find that root in inorder, and everything left of it is the left subtree, everything right is the right subtree. Build a hash map from value to inorder index so lookups are O(1). Then for each subtree, filter the level-order array to keep only values in that subtree's inorder set, preserving order. The first kept value is the subtree root. Recurse on both halves. The common pitfall is scanning for the root in inorder every call, which gives O(n^2) or worse. Another is forgetting to keep level-order relative order when you split. With n up to 1200, a filtered recursion is fine. A queue-based version with index ranges also works. If the recursion tangles on the live OA, StealthCoder is the hedge that gets you a clean working solution while you keep your head straight.

StealthCoder is the hedge for the one pattern you didn't drill. It runs invisibly during the screen share.