Swap Nodes in Pairs - Practice Coding Problems

Swap Nodes in Pairs - Problem

Swap Adjacent Node Pairs in a Linked List

Imagine you have a chain of connected nodes, and you need to swap every two adjacent nodes while keeping the chain intact. Given the head of a linked list, your task is to swap every two adjacent nodes and return the new head of the modified list.

Key Rules:

You can only change the node connections - not the values inside the nodes
If there's an odd number of nodes, the last node remains in its original position
The solution should work in-place without creating new nodes

Example: 1→2→3→4 becomes 2→1→4→3

Input & Output

example_1.py — Basic Even Length List

$ Input: head = [1,2,3,4]

› Output: [2,1,4,3]

💡 Note: The first pair (1,2) swaps to (2,1), and the second pair (3,4) swaps to (4,3). Result: 2→1→4→3

example_2.py — Odd Length List

$ Input: head = [1,2,3]

› Output: [2,1,3]

💡 Note: The first pair (1,2) swaps to (2,1), but node 3 has no pair so it remains in place. Result: 2→1→3

example_3.py — Edge Cases

$ Input: head = [] OR head = [1]

› Output: [] OR [1]

💡 Note: Empty list returns empty. Single node has no pair to swap with, so it remains unchanged.

Constraints

The number of nodes in the list is in the range [0, 100]
0 ≤ Node.val ≤ 100
You must solve the problem without modifying the values in the list's nodes (i.e., only nodes themselves may be changed)

Visualization

Tap to expand

Understanding the Visualization

Setup Stage

Place a director (dummy node) at the front to coordinate the swaps

Identify Partners

Point to the next two dancers who need to swap positions

Coordinate Swap

Carefully rewire connections so partners swap without breaking the line

Move to Next Pair

Director moves to supervise the next pair of dancers

Key Takeaway

🎯 Key Insight: Use a dummy node as an anchor and maintain careful pointer tracking to swap pairs efficiently without losing connections in the linked list.

Asked in

⊞ Microsoft 45 a Amazon 38 G Google 32 f Meta 28 Apple 22

The optimal solution uses iterative pointer manipulation with a dummy node. Key technique: maintain a prev pointer to track the node before each pair, then rewire pointers to swap adjacent nodes. This achieves O(1) space and O(n) time complexity while handling all edge cases elegantly.

Common Approaches

Approach	Time	Space	Notes
✓ Iterative Pointer Manipulation	O(n)	O(1)	Use iterative approach with careful pointer manipulation to swap pairs

Iterative Pointer Manipulation — Algorithm Steps

Create a dummy node pointing to the head to handle edge cases
Use a prev pointer to track the node before current pair
For each pair, identify first and second nodes
Rewire the pointers: prev→second, first→second.next, second→first
Update prev to point to first (now second in pair) and continue

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set up dummy node and prev pointer

Identify Pair

Find first and second nodes of current pair

Rewire Pointers

Update pointers to swap the pair

Move Forward

Update prev and continue to next pair

Code -

solution.c — C

// Definition for singly-linked list
struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* swapPairs(struct ListNode* head) {
    // Create dummy node to simplify edge cases
    struct ListNode* dummy = malloc(sizeof(struct ListNode));
    dummy->val = 0;
    dummy->next = head;
    struct ListNode* prev = dummy;
    
    // Continue while we have at least 2 nodes to swap
    while (prev->next && prev->next->next) {
        // Identify the two nodes to swap
        struct ListNode* first = prev->next;
        struct ListNode* second = prev->next->next;
        
        // Perform the swap
        prev->next = second;
        first->next = second->next;
        second->next = first;
        
        // Move prev to the end of swapped pair
        prev = first;
    }
    
    struct ListNode* result = dummy->next;
    free(dummy);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the linked list, visiting each node exactly once

✓ Linear Growth

Space Complexity

O(1)

Only uses a constant number of pointers regardless of input size

✓ Linear Space

52.3K Views

High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Iterative Pointer Manipulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler