【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;
}