24. Swap Nodes in Pairs，交换单链表相邻节点

Example 1:
Input: head = [1,2,3,4]
Output: [2,1,4,3]

Example 2:
Input: head = []
Output: []

Example 3:
Input: head = [1]
Output: [1]

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        p = q = head
        if p and p.next:
            head = p.next
            p = q.next = head.next
            head.next = q
            while p and p.next:
                q.next = p.next
                p.next = p.next.next
                q.next.next = q = p
                p = p.next
        return head

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) noexcept{
        ListNode *h { head };
        if(head && head->next){
            head = h->next;
            h->next = head->next;
            head->next = h;
            ListNode *k1 { h->next };
            while(k1 && k1->next){
                ListNode *k2 { k1->next };
                k1->next = k2->next;
                k2->next = k1;
                h->next = k2;
                h = k1;
                k1 = k1->next;
            }
        }
        return head;
    }
};
/*class Solution {
public:
    ListNode* swapPairs(ListNode* head) noexcept{
        ListNode *k, *h;
        k = h = head;
        if(head && head->next){
            head = head->next;
            k = h->next = head->next;
            head->next = h;
            while(k && k->next){
                h->next = k->next;
                k->next = k->next->next;
                h = h->next->next = k;
                k = k->next;
            }
        }
        return head;
    }
};*/

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* swapPairs(struct ListNode* head) {
    struct ListNode *k, *h;
    k = h = head;
    if(head && head->next){
        head = head->next;
        h->next = k = head->next;
        head->next = h;
        while(k && k->next){
            h->next = k->next;
            k->next = k->next->next;
            h = h->next->next = k;
            k = k->next;
        }
    }
    return head;
}

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if head and head.next:
            p = head.next
            head.next = self.swapPairs(p.next)
            p.next = head
            return p
        return head

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* swapPairs(struct ListNode* head) {
    if(head && head->next){
        struct ListNode *p = head;
        head = head->next;
        p->next = swapPairs(head->next);
        head->next = p;
    }
    return head;
}

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) noexcept{
        if(head && head->next){
            ListNode *p = head->next;
            head->next = swapPairs(p->next);
            p->next = head;
            return p;
        }
        return head;
    }
};