In these Leetcode Swap Nodes in Pairs problem solutions, we have given a linked list, swap every adjacent node, and return its head. You must solve the problem without modifying the values in the list's nodes.

Leetcode Swap Nodes in Pairs problem solution


Problem solution in Python.

def swapPairs(self, head: ListNode) -> ListNode:
    h = head
    while head and head.next:
        head.val, head.next.val = head.next.val, head.val
        head = head.next.next
    return h



Problem solution in Java.

public ListNode swapPairs(ListNode head) {
        ListNode n = helper(head);
        return n; 
    }
    
    public ListNode helper(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }    
        
        ListNode tmp = head;
        ListNode next = head.next;
        
        head.next = next.next;
        next.next = tmp; 
        head.next = helper(head.next); 
        return next;
    }


Problem solution in C++.

void _swapPairs(ListNode* odd, ListNode* even, ListNode** prev) {
        if (!odd || !even) return;
        *prev = even;
        ListNode* temp = even->next;
        even->next = odd;
        odd->next = temp;
        _swapPairs(odd->next, odd->next ? odd->next->next: NULL, &odd->next);
    }
    ListNode* swapPairs(ListNode* head) {
        _swapPairs(head, head ? head->next : NULL, &head);
        return head;
    }


Problem solution in C.

struct ListNode* swapPairs(struct ListNode* head) {
    typedef struct ListNode Node;
    Node *root  = head;
    Node *prev = NULL;
    int temp;
    int count = 0;
    while(head != NULL){
        if(count %2 == 1){
            temp = prev->val;
            prev->val = head->val;
            head->val = temp;
        }
        prev = head;
        head = head->next;
        count++;
    }
    return root;
}