Leetcode Swap Nodes in Pairs problem solution

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.

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;
}