leetcode 24 两两交换链表中的数据

思路比较清晰，使用快慢指针，每次循环中要完成的任务就是实现第一个指针的next对象与第二个指针对象的交换，完成之后检测后面是否存在两个需要进行交换的节点，如果没有，则完成交换，程序返回。如果判断后面还有两个节点需要进行交换，则使两个指针分别向后推两位，重新进行循环。代码如下：

/**
 * 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) 
    {
        if(!head)
        return head;
        ListNode* temp1;
        ListNode* temp2;
        ListNode* temp3;
        temp1 =new ListNode(0,head);
        temp3 = temp1;
        temp2 = head->next;
        while(temp1 && temp2)
        {
            ListNode* Node2 = temp1->next;
            ListNode* Node3 = temp2;
            ListNode* Node4 = temp2->next;
            temp1->next = Node3;
            temp2->next = Node2; 
            temp2->next->next = Node4;
            temp2 = temp2->next;
            if(temp2->next && temp2->next->next) 
            {
                temp1 = temp1->next->next;
                temp2 = temp2->next->next;
            }
            else
            {
                return temp3->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) 
    {
        if(!head || !head->next)
        return head;
        ListNode* nextNode = head->next;
        head->next = swapPairs(head->next->next);
        nextNode->next = head;
        return nextNode;        
    }
};