24.两两交换链表中的节点(给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。)_给定一个(单链表), 每隔两个相邻节点交换一次(交换相邻节点) 并将指针返回到修改

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

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例 1：

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

示例 2：
输入：head = []
输出：[]

示例 3：
输入：head = [1]
输出：[1]

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

咋说呢，我觉得我做出来的题就不是很难，所以这道题不难。
但是，这种链表题对我来说是一如既往的绕。。。

交换两个节点，首先得判断是不是前两个节点位置的交换，因为第一个节点没有前一个节点，而之后的节点交换中两个节点有前节点。

这是交换前两个节点：

ListNode* a = head->next;
        if(head->next != nullptr){
            head->next = head->next->next;
            a->next = head;
        }
        head = a;//很关键，因为交换完之后，就是a开头，要让head=a。
1
2
3
4
5
6

写上面这块的时候，就很绕。。。令人头疼，虽然不难但是很绕。

完整代码：

/**
 * 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) {
        ListNode* temp = head;
        //head第一个节点不为空
        if(head == nullptr || head->next == nullptr){
            return head;
        }
        ListNode* a = head->next;
        if(head->next != nullptr){
            head->next = head->next->next;
            a->next = head;
        }
        head = a;
        temp = a->next;
        while(temp->next != nullptr && temp->next->next != nullptr){//交换两个的位置
            ListNode* b = temp->next;
            ListNode* c = temp->next->next;
            b->next = c->next;
            c->next = b;
            temp->next = c;
            temp = temp->next->next;
        }
        return head;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

也不知道是不是自己的能力提升的那么一点点，哈。
下面是个人ing
（学弟简直不要太强，一个理学院的学弟就有这么高的理想，真佩服！虽然算法这一块会的不多，但他也太努力了吧！！自愧不如，要向优秀的人学习。还有一个超厉害的学长！！！我什么时候也可以成为那样优秀的人呐。）
坚持！
一个集坚强与自信于一身的菇凉。