24. 两两交换链表中的节点

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

#include<iostream>
using namespace std;
struct ListNode {
    int val;
    ListNode* next;
    
    ListNode(int value) : val(value), next(nullptr) {}
};

ListNode* createSList(int* nums, int sz) {
    ListNode* head = nullptr;
    ListNode* tail = nullptr;

    for (int i = 0; i < sz; ++i) {
        ListNode* newNode = new ListNode(nums[i]);

        if (tail == nullptr) {
            head = tail = newNode;
        } else {
            tail->next = newNode;
            tail = newNode;
        }
    }

    return head;
}

void destroySList(ListNode* head) {
    while (head != nullptr) {
        ListNode* temp = head;
        head = head->next;
        delete temp;
    }
}

ListNode* swapPairs(ListNode* head) {
        /*
            算法思想：双指针法
        */
        if(!head || !head -> next){
            return head;
        }
        ListNode* dummy = new ListNode(0);
        dummy -> next = head;               // 0 -> 1
        ListNode* node0 = dummy;
        ListNode* node1 = head;
        while(node1 != nullptr && node1 -> next != nullptr){
            ListNode* node2 = node1 -> next;    
            ListNode* node3 = node2 -> next;
            
            //循环的操作
            node0 ->next = node2;               //0 -> 2 ;
            node2 -> next = node1;              //2 -> 1
            node1 -> next = node3;              //1 -> 3
            
            node0 = node1;
            node1 = node1 -> next;
            
        }
        return dummy -> next;
}
int main() {
    int arr[] = {1, 2, 3, 4};
    int sz = sizeof(arr) / sizeof(arr[0]);
    ListNode* head = createSList(arr, sz);
    ListNode* p = swapPairs(head);
    //遍历链表
    while(p != nullptr){
        cout << p -> val << " ";
        p = p -> next;
    }
    // 在程序结束前释放链表占用的内存
    destroySList(head);
    return 0;
}

2 1 4 3