Swap Nodes in Pairs

Copy values + rebuild

Start with the most direct model of the result. Copy every value into an array, swap neighboring array entries, then build a fresh list in that order.

def swap_pairs(head: ListNode | None) -> ListNode | None:
    values: list[int] = []
    current = head
    while current is not None:
        values.append(current.val)
        current = current.next
 
    for i in range(0, len(values) - 1, 2):
        values[i], values[i + 1] = values[i + 1], values[i]
 
    dummy = ListNode()
    tail = dummy
    for value in values:
        tail.next = ListNode(value)
        tail = tail.next
    return dummy.next

This gets the returned order right, but it copies the entire list and replaces the original nodes. It gives you a trustworthy baseline before you tackle the links.

Time O(n) — read, swap, and rebuild at most n items each. Space O(n) for the array and the rebuilt list, excluding the returned nodes themselves.

Dummy head + relinking

A dummy node is a temporary node placed before the real head so the first pair and every later pair follow the same rules. Keep previous just before the pair, then name the next two nodes first and second.

Save second.next before changing anything. Then connect the three links in their new order: previous → second → first → remainder.

def swap_pairs(head: ListNode | None) -> ListNode | None:
    dummy = ListNode(0, head)
    previous = dummy
 
    while previous.next is not None and previous.next.next is not None:
        first = previous.next
        second = first.next
 
        first.next = second.next
        second.next = first
        previous.next = second
 
        previous = first
 
    return dummy.next

After each round, first has become the tail of the swapped pair. Moving previous there puts it directly before the next untouched pair. If fewer than two nodes remain, the loop stops and an odd final node is already in the right place.

Time O(n) — each node is visited a constant number of times. Space O(1) — only a few pointers and one temporary dummy node are used.