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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

• 链表中节点的数目在范围 [0, 100] 内
• 0 <= Node.val <= 100

思路：要实现两个节点node1,node2的交换必然需要三个指针实现，其中两个指针分别指向两个节点，另一个指针指向node1的前一个节点。根据代码画图理解交换过程：

q->next=w->next;
            p->next=w;
            w->next=q

为使后续节点也能循环使用该代码，需要将p,q,w分别按照相对位置指向下一对要交换的结点。

/**
 * 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) {
        //交换节点a,b(a->b)位置时，p指向a的前一个节点，q指向a节点，w指向b节点
        if(head==NULL) return NULL;
        ListNode* newhead;
        ListNode* p=new ListNode(-1);
        newhead=p;//有头节点
        ListNode* q=head;
        //，w 的声明在条件语句 if(head->next!=NULL) 内部，因此在条件之外的范围不可见。
        //这导致在使用 w 时，编译器无法识别 w
        // if(head->next!=NULL)
        // ListNode* w=head->next;
        // else return head;
        ListNode* w;
        if(head->next!=NULL) w=head->next;
        else return head;

        while(w!=NULL){
            //实现交换
            q->next=w->next;
            p->next=w;
            w->next=q;
            //将p,q,w移动到下一组需要交换的节点对应地址上
            p=q;
            if(q->next!=NULL) q=q->next;
            else break;
            if(q->next!=NULL) w=q->next;
            else break;
        }

return newhead->next;

    }
};