解法一：暴力

暴力解法要注意引入哨兵节点，因为第一次交换需要将p指向哨兵位，然后对p.next，p.next.next，p.next.next.next进行交换操作，以保证head不丢失。交换顺序如下：
p-1-2-3：先让1指向3，然后让2指向1，最后让p指向2。此时完成1、2的交换，随后将p移至3，开始下一组交换。当p后只有0个或1个元素时，程序停止。

  1. class Solution:
  2.     def swapPairs(self, head: ListNode) -> ListNode:
  3.         p = dummy = ListNode(next=head)
  4.         while p.next and p.next.next:
  5.             pnn = p.next.next
  6.             p.next.next = pnn.next
  7.             pnn.next = p.next
  8.             p.next = pnn
  9.             p = p.next.next
  10.         return dummy.next

解法二：递归

递归方法非常简洁，从算法模型上来说是非常好的思路，但无法回避递归深度问题。
子问题：交换head与head.next两个节点组成的链表，并将交换后的链表与后面已经完成交换的链表头进行链接。
退出条件：子问题中的节点不足两个，直接返回head。
递归法从链表尾部开始交换，返回交换后的head。当尾部少于2个节点时，直接返回head，否则返回交换后的head作为tmp，参与当前的head与head.next的交换。

  1. class Solution:
  2.     def swapPairs(self, head: ListNode) -> ListNode:
  3.         if not head or not head.next:
  4.             return head
  5.         tmp = self.swapPairs(head.next.next)
  6.         res = head.next
  7.         res.next = head
  8.         head.next = tmp
  9.         return res