Swapping Nodes in a Linked List - Practice Coding Problems

Swapping Nodes in a Linked List - Problem

Imagine you have a chain of connected nodes, and you need to perform a symmetric swap operation. You're given the head of a linked list and an integer k.

Your task is to swap the values of two specific nodes:

The kth node from the beginning (1-indexed)
The kth node from the end (1-indexed)

For example, in a list [1,2,3,4,5] with k=2, you would swap the 2nd node from start (value 2) with the 2nd node from end (value 4), resulting in [1,4,3,2,5].

Important: You only need to swap the values, not the actual node positions. Return the head of the modified linked list.

Input & Output

example_1.py — Basic Case

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

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

💡 Note: Swap the 2nd node from beginning (value 2) with 2nd node from end (value 4). The result is [1,4,3,2,5].

example_2.py — Middle Element

$ Input: head = [7,9,6,6,7,8,3,0,9,5], k = 5

› Output: [7,9,6,6,8,7,3,0,9,5]

💡 Note: Swap the 5th node from beginning (value 7) with 5th node from end (value 8). In a 10-node list, 5th from end is 6th from beginning.

example_3.py — Single Node

$ Input: head = [1], k = 1

› Output: [1]

💡 Note: With only one node, the 1st from beginning and 1st from end are the same node. Swapping it with itself results in no change.

Constraints

The number of nodes in the list is n
1 ≤ n ≤ 10⁵
0 ≤ Node.val ≤ 100
1 ≤ k ≤ n

Visualization

Tap to expand

Understanding the Visualization

Initialize Pointers

Both pointers start at the head of the linked list

Create Gap

Move first pointer k steps ahead, creating a k-node gap

Save Reference

Store reference to the kth node from beginning

Move Together

Advance both pointers until first reaches the end

Swap Values

Second pointer is now at kth from end, swap the values

Key Takeaway

🎯 Key Insight: The gap technique automatically positions the second pointer at the kth node from the end when the first pointer reaches the end, eliminating the need for list length calculation.

Asked in

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

The optimal solution uses a two-pointer technique with a strategic k-distance gap. By moving the first pointer k steps ahead initially, then advancing both pointers together until the first reaches the end, the second pointer automatically lands on the kth node from the end. This eliminates the need for counting nodes and achieves O(n) time with O(1) space in a single pass.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(1)	Use two pointers with k-distance gap to find both nodes in single pass
Two-Pass Traversal	O(n)	O(1)	Count nodes first, then locate and swap the target nodes

Two Pointers (Optimal) — Algorithm Steps

Initialize two pointers: first and second, both starting at head
Move first pointer k steps ahead to create k-distance gap
Store reference to kth node from beginning during this process
Move both pointers together until first reaches the end
Second pointer now points to kth node from end
Swap values of the two identified nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup Gap

Move first pointer k steps ahead

Save Reference

Store kth from beginning node

Move Together

Advance both pointers until first reaches end

Swap Values

Second pointer is now at kth from end

Code -

solution.c — C

struct ListNode* swapNodes(struct ListNode* head, int k) {
    struct ListNode* first = head;
    struct ListNode* second = head;
    
    // Move first pointer k steps and identify kth from beginning
    for (int i = 0; i < k - 1; i++) {
        first = first->next;
    }
    
    // Store kth node from beginning
    struct ListNode* kthFromStart = first;
    
    // Move first to the end, second will be at kth from end
    while (first->next) {
        first = first->next;
        second = second->next;
    }
    
    // second now points to kth from end
    struct ListNode* kthFromEnd = second;
    
    // Swap values
    int temp = kthFromStart->val;
    kthFromStart->val = kthFromEnd->val;
    kthFromEnd->val = temp;
    
    return head;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the list, visiting each node exactly once

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for pointers and variables

✓ Linear Space

89.6K Views

Medium Frequency

~15 min Avg. Time

2.3K 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

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler