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

Binary Tree Preorder Traversal

Binary Tree Postorder Traversal

Maximal Square

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

Given the `root` of a binary tree, return its **preorder traversal** as an array of node values. Preorder means you visit the current node first, then the left subtree, then the right subtree, so the order is fully deterministic for any tree shape.

If the tree is empty, return an empty array. The example below shows how the traversal proceeds, the constraints are small enough for either recursion or an explicit stack, and the follow-up asks you to think about the iterative version too.

**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,2,3]
```

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

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

Preorder traversal always does the same three actions at every node: record the current node, traverse the left subtree, then traverse the right subtree. That makes this a standard depth-first search problem with a deterministic visit order.

Recognize the preorder pattern

Use a helper DFS that stops on `None`, appends the current node's value first, then recursively processes the left child and the right child. This matches the definition of preorder traversal directly.

Recursive DFS solution

Time: O(n) because each node is visited exactly once. Space: O(h) for the explicit stack, where `h` is the tree height (`O(n)` in the worst skewed case). This stack-based preorder traversal is an optimal approach that avoids recursion depth concerns: pop a node, record it, then push its right child before its left child so the left subtree is processed first.