Swap Nodes in Pairs

Swap Nodes in Pairs - Problem

Given the head of a linked list, swap every two adjacent nodes and return its head.

You must solve the problem without modifying the values in the list's nodes (i.e., only nodes themselves may be changed).

For example, if the linked list is 1→2→3→4, the result should be 2→1→4→3.

Input & Output

Example 1 — Four Node List

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

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

💡 Note: Swap pairs (1,2) and (3,4): 1→2→3→4 becomes 2→1→4→3

Example 2 — Odd Length List

$ Input: [1,2,3]

› Output: [2,1,3]

💡 Note: Swap pair (1,2), leave 3 unchanged: 1→2→3 becomes 2→1→3

Example 3 — Empty List

$ Input: []

› Output: []

💡 Note: Empty list remains empty

Constraints

The number of nodes in the list is in the range [0, 100]
0 ≤ Node.val ≤ 100

Visualization

Tap to expand

Asked in

f Facebook 42 M Microsoft 38 a Amazon 35 G Google 28

The key insight is to safely swap adjacent pairs by either using a dummy node for iterative approach or leveraging recursion's natural divide-and-conquer. Best approach is iterative with dummy node for O(1) space. Time: O(n), Space: O(1) for iterative or O(n) for recursive.

Common Approaches

✓ Iterative with Dummy Node

⏱️ Time: O(n) Space: O(1)

Create a dummy node pointing to head, then iterate through the list swapping every two adjacent nodes by carefully updating pointers. Track previous node to maintain connections.

Recursive Approach

⏱️ Time: O(n) Space: O(n)

For each pair, swap the first two nodes and recursively call the function on the remaining list. The base case handles when there are fewer than 2 nodes left.

Iterative with Dummy Node — Algorithm Steps

Create a dummy node pointing to head for easier edge case handling
Use prev pointer to track the node before current pair
For each pair, update pointers: prev→next = second, first→next = second→next, second→next = first
Move prev to first (which is now second in the pair) and continue

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Create dummy node and set prev pointer

Swap

Identify first and second nodes, update pointers to swap them

Continue

Move prev to swapped first node and repeat

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct ListNode {
    int val;
    struct ListNode* next;
};

struct ListNode* solution(struct ListNode* head) {
    if (!head || !head->next) {
        return head;
    }
    
    struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummy->val = 0;
    dummy->next = head;
    struct ListNode* prev = dummy;
    
    while (prev->next && prev->next->next) {
        struct ListNode* first = prev->next;
        struct ListNode* second = prev->next->next;
        
        prev->next = second;
        first->next = second->next;
        second->next = first;
        
        prev = first;
    }
    
    struct ListNode* result = dummy->next;
    free(dummy);
    return result;
}

struct ListNode* arrayToList(int* arr, int size) {
    if (size == 0) return NULL;
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->val = arr[0];
    head->next = NULL;
    struct ListNode* current = head;
    for (int i = 1; i < size; i++) {
        current->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        current = current->next;
        current->val = arr[i];
        current->next = NULL;
    }
    return head;
}

int* listToArray(struct ListNode* head, int* size) {
    *size = 0;
    struct ListNode* current = head;
    while (current) {
        (*size)++;
        current = current->next;
    }
    
    int* result = (int*)malloc(*size * sizeof(int));
    current = head;
    for (int i = 0; i < *size; i++) {
        result[i] = current->val;
        current = current->next;
    }
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int arr[100];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    while (token) {
        arr[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    struct ListNode* head = arrayToList(arr, size);
    struct ListNode* result = solution(head);
    
    int resultSize;
    int* resultArr = listToArray(result, &resultSize);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        printf("%d", resultArr[i]);
        if (i < resultSize - 1) printf(",");
    }
    printf("]\n");
    
    free(resultArr);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the linked list visiting each node once

✓ Linear Growth

Space Complexity

O(1)

Only uses constant extra space for pointer variables

✓ Linear Space

425.0K Views

High Frequency

~15 min Avg. Time

9.0K 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 with Dummy Node — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler