【LeetCode】成对交换节点

e.g. 给定链表 1->2->3->4，返回 2->1->4->3 的头节点。

我写了个常见的从头节点遍历，少量的奇数个或偶数个数据都能成功重新排列。但链表过长时结果显示 Time Limit Exceeded 。

 ListNode* swapPairs(ListNode* head) {
     ListNode *p = head, *q, *pre;
     while (p) {
         if (q = p->next) {
             if (p == head)  head = q;
             p->next = q->next;
             q->next = p;
             if (pre)    pre->next = q;
         }
         pre = p;
         p = p->next;
     }
     return head;
 }

看到有一个答案使用二级指针，忘了这种方法了！

pp 从指向 head 指针到指向所有 next 指针遍历下去，p 指向 *pp 表示指向当前结点，q 指向 p 的下一个节点。

 ListNode* swapPairs(ListNode* head) {
     ListNode **pp = &head, *p, *q;
     while ((p = *pp) && (q = p->next)) {
         p->next = q->next;
         q->next = p;
         *pp = q;
         pp = &(p->next);
     }
     return head;
 }

看到有些答案标题写使用递归，想了下，把两种思路都 DIY 为递归方法，Accepted了。

 ListNode* swapPairs(ListNode* head) {
     if (!head || !head->next)  return head;
     ListNode *p = head, *q = p->next;
     if (!q->next)
         p->next = NULL;
     else
         p->next = swapPairs(q->next);
     q->next = p;
     return q;
 }

 ListNode* swapPairs(ListNode* head) {
     if (!head || !head->next)    return head;
     ListNode **pp = &head, *q = (*pp)->next;
     (*pp)->next = swapPairs(q->next);
     q->next = *pp;
     pp = &q;
     return *pp;
 }

可以看到二级指针代码量确实会少一点，而且使用递归代替迭代有时能减少时间。

但答案这种递归方法最为简单，只用定义一个指针。改为使用二级指针目测无法实现。

 ListNode* swapPairs(ListNode* head) {
     if(!head || !head->next)    return head;
     ListNode *next = head->next;
     head->next = swapPairs(next->next);
     next->next = head;
     return next;
 }