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

Binary Tree Postorder Traversal

Valid Sudoku

Binary Tree Preorder Traversal

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

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

If the tree is empty, return an empty array. The example below shows the required order, and the constraints and follow-up appear afterward.

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

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

## Follow-up
The recursive solution is the clearest starting point, but can you also solve it iteratively using a single stack? An iterative solution without a second stack is trickier because you need to know when a node's right subtree has already been processed.

Postorder traversal is defined recursively: traverse the left subtree, then the right subtree, then record the current node. A helper DFS mirrors that definition directly and is the easiest way to get started.

Recursive depth-first traversal

To avoid recursion, simulate the call stack yourself. Walk left as far as possible, peek at the top node, and only visit it after its right subtree is done. Tracking the last visited node lets one stack handle the full postorder order, which is more efficient than using a second stack but also a bit trickier to reason about.