Return the values of a binary tree in left-node-right order. Test your code, then compare with the explained solution. Free online practice.

Binary Tree Inorder Traversal

3Sum Closest

Sort List

Return the values of a binary tree in left-node-right order.

Given the `root` of a binary tree, return its **in-order traversal** as an array of node values. In-order means you visit the left subtree first, then the current node, then the right subtree.

If the tree is empty, return an empty array.

**Input / output**
- Input: `root: TreeNode` (the JSON test fixture is a LeetCode-style level-order array, e.g. `[1,null,2,3]`, using `null` for missing children)
- Output: `int[]`

## Example
```json
Input: {"root":[1,null,2,3]}
Output: [1,3,2]
```

## Constraints
- 0 <= number of nodes <= 100
- -100 <= Node.val <= 100

## Follow-up
The recursive solution is natural here, but can you also solve it iteratively using an explicit stack?

In-order traversal always follows the same pattern at every node: visit the left subtree, then record the current node, then visit the right subtree. That makes this a straightforward depth-first search problem.

Recognize the traversal order

Use a helper DFS that stops on `None`, recursively processes the left child, appends the current value, and then processes the right child. This mirrors the definition of in-order traversal directly.

Recursive DFS solution

An empty tree should return `[]`. A single node should return just that value. Skewed trees should still work because the traversal naturally unwinds back up the call stack in the correct left-node-right order.

Think through edge cases

Time: O(n) because each node is pushed and popped at most once. Space: O(h) for the stack, where `h` is the tree height (`O(n)` worst case on a skewed tree). The iterative version simulates the recursive call stack explicitly: keep walking left, pop the next node to visit, record it, then move to its right subtree.