Swap Nodes in Pairs

Binary Tree Right Side View

Reverse Linked List II

Swap every adjacent pair of nodes in a singly linked list without changing the node values.

Given the `head` of a singly linked list, swap every two adjacent nodes and return the head of the modified list. You must solve it by only changing node links (not the values stored inside the nodes).

**Input / output**
- Input: `head: ListNode` (JSON test fixture is a plain array of node values, e.g. `[1, 2, 3, 4]` means `1 -> 2 -> 3 -> 4 -> null`)
- Output: `ListNode` (serialized the same way)

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

## Constraints
- The number of nodes in the list is between 0 and 100.
- `0 <= node value <= 100`

## Follow-up
Can you solve it both iteratively (with a dummy head and a `prev` pointer) and recursively, and explain why the recursive version costs O(n) call-stack space that the iterative version avoids?

The key pattern is: a dummy-node walk that repoints three links at a time — `prev`, the first node of the pair, and the second node of the pair. 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(1) auxiliary for the iterative Python/JavaScript/Java/Go solutions. The Rust solution here is written recursively for idiomatic ownership handling of `Option<Box<ListNode>>` swaps, so it costs O(n) call-stack space instead.

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