题目

Leetcode题目链接
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例：
输入：1->2->3->4
返回：2->1->4->3

思路

遍历法

使用遍历的方法两两进行交换即可。
假如链表为：1->2->3，
在交换1->2时，只需要1->next->next=1，1->next=3，即可将链表修改为2->1->3。
这里需要注意的是在遍历时需要保存每次遍历前的节点prev，以及下一次要遍历的节点tmp。
保存每次遍历前的节点prev是为了让prev指向交换后的节点，否则会丢失信息。
比如链表为1->2->3->4->null；
我们两两遍历，先交换1->2，然后交换3->4；
按照上述方法交换1->2后，链表为2->1->3->4；
再次交换3->4，链表为2->1->3<-4；
我们需要使用prev指针保存上一次交换后的节点1，然后令1->4，链表才能正确输出为2->1->4->3；
时间复杂度为O(n)；
空间复杂度为O(1)；

c++代码

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head == NULL || head->next == NULL) return head;
        ListNode *cur, *tmp, *prev;
        prev= cur = head;
        head = head->next;

        while(cur)
        {
            if(cur->next == NULL) break;   //如果不够两个节点就跳出循环
            tmp = cur->next->next;    //保存下一次要遍历的节点
            prev->next = cur->next;
            cur->next->next = cur;
            cur->next = tmp;
            prev = cur;   //保存前一次遍历的最后一个节点
            cur = tmp;  
        }

        return head;
    }
};

python代码

class Solution:
    def swapPairs(self, head: ListNode) -> ListNode:
        pre, pre.next = self, head
   
        while pre.next and pre.next.next:
            a = pre.next
            b = pre.next.next
            pre.next, a.next, b.next = b, b.next, a
            pre = a

        return self.next

递归法

使用递归的方法交换相邻节点，其实就是将上个方法的循环改为递归。
时间复杂度为O(n)；
空间复杂度为O(n)，递归需要用到栈空间。

c++代码1

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head == NULL || head->next == NULL) return head;
        ListNode* p = swapPairs(head->next->next);
        head->next->next = head;
        ListNode* prev = head->next;
        head->next = p;
        
        return prev;
    }
};

c++代码2

class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next == null){
            return head;
        }
        ListNode next = head.next;
        head.next = swapPairs(next.next);
        next.next = head;
        return next;
    }
}

这个写法和上述写法只是顺序的不同