Swap Nodes in Pairs | Pointer Updates | Linked List

Overview

Swap nodes in pairs means swapping every two adjacent nodes in a linked list: (1,2) → (2,1), (3,4) → (4,3), etc. If the length is odd, the last node stays. You do it in-place with a Dummy Head so the first pair is handled like every other pair: keep a prev pointer to the node before the current pair, then rewire the three links (prev → second, first → second.next, second → first), and advance prev to the node that is now second in the pair.

Key idea: For each pair (first, second), you need to set: the node before the pair points to second; first points to what second pointed to; second points to first. A dummy gives you a consistent "node before the pair" for the first pair.

When to Use

Swap nodes in pairs — Exact problem.
Reverse in fixed-size groups — Same idea generalizes to Reverse Nodes in K-Group (k=2 is swap pairs).

How It Works

Dummy: dummy.next = head; prev = dummy.
While there are at least two nodes (prev.next and prev.next.next exist):

first = prev.next, second = prev.next.next.
prev.next = second.
first.next = second.next.
second.next = first.
prev = first (the node that is now second in the pair; the next "pair" starts after it).

Return dummy.next.

Example 1: Swap Nodes in Pairs

Problem: Given the head of a linked list, swap every two adjacent nodes and return the new head. You may not modify values, only pointers.

function swapPairs(head: ListNode | null): ListNode | null {
  const dummy = new ListNode(-1);
  dummy.next = head;
  let prev: ListNode = dummy;
  while (prev.next !== null && prev.next.next !== null) {
    const first = prev.next;
    const second = prev.next.next;
    prev.next = second;
    first.next = second.next;
    second.next = first;
    prev = first;
  }
  return dummy.next;
}

Time: O(n), Space: O(1).

Edge Cases

Empty list — Loop doesn't run; return dummy.next (null).
Single node — prev.next.next is null; loop doesn't run; return head.
Two nodes — One iteration; result is second → first → null.

Common Mistakes

Losing references — Save first and second (or second.next) before rewiring; first.next must become second.next before you overwrite second.next.
Wrong advance — After swapping, the "previous" for the next pair is the node that was first (now in second position); so prev = first.
Skipping the dummy — Without it, the first pair has no "prev"; you'd need separate logic for the head.

Time and Space Complexity

Time: O(n).
Space: O(1).

Summary

Swap pairs: Dummy + prev; while two nodes exist, rewire prev → second, first → second.next, second → first; prev = first; return dummy.next.
Generalizes to Reverse Nodes in K-Group. See Dummy Head and Reverse In-Place.