Binary Tree Right Side View

Merge Two Binary Trees

Swap Nodes in Pairs

Return the values visible when looking at a binary tree from the right side, ordered top to bottom.

Given the `root` of a binary tree, imagine standing on the right side of it. Return the values of the nodes you can see, ordered from top to bottom — that is, the last (rightmost) node visited at each level.

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

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

## Constraints
- 0 <= number of nodes <= 100
- -100 <= node value <= 100

## Follow-up
Can you solve it with a single recursive DFS pass (visiting right children before left, recording the first node seen at each depth) instead of a level-by-level BFS?

The key pattern is: level-order BFS that only keeps the last node processed at each depth. Identify the state and invariant before coding.

Recognize the Pattern

Advance one state transition at a time. Mark or update state before exploring dependent work.

Build the Algorithm

Test empty or minimal input, skewed shapes, duplicates where allowed, and impossible outcomes.

Check Edge Cases

Time: O(n) — every node is visited once. Space: O(w) for the queue, where w is the widest level of the tree (O(n) worst case on a complete tree).

All 5 languages below run and submit against the remote judge for this problem — Java/Go/Rust use the same real TreeNode structural-type support the judge added for the rest of the linked-list/tree track.