24. 两两交换链表中的节点

24. 两两交换链表中的节点

题目描述

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例1：

​

输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例2：

输入：head = []
输出：[]

示例3：

输入：head = [1]
输出：[1]

提示：

• 链表中节点的数目在范围 [0, 100] 内
• $0\le Node.val\le 100$

---

题解：

链表模拟，这题不想清楚有点难写。。。

1. 首先添加一个哨兵节点 dummy
2. 令 now 指向 dummy ，now 指向的是已交换部分最后一个节点
3. second = now->next ，first = second->next ，两者有一个为空退出循环，节点不能继续交换
4. now = second ，继续第 3 步

代码：

/**
 * 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 *dummy = new ListNode();
        dummy->next = head;

        ListNode *first = nullptr, *second = nullptr, *now = dummy;
        while ( now ) {
            if ( !now->next ) break;
            second = now->next;

            if ( !second->next ) break;
            first = second->next;

            now->next = first;
            second->next = first->next;
            first->next = second;
            
            now = second;
        }
        return dummy->next;
    }
};
/*
时间：0ms，击败：100.00%
内存：7.2MB，击败：99.93%
*/

贴一版乱糟糟的代码：

/**
 * 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 *dummy = new ListNode();
        dummy->next = head;

        ListNode *first = dummy->next->next, *second = dummy->next, *pre = dummy; 
        while ( true ) {
            second->next = first->next;
            first->next = second;
            pre->next = first;
            pre = second;
            if ( second->next ) {
                second = second->next;
                if ( second->next ) first = second->next;
                else break;
            } else break;
        }
        return dummy->next;
    }
};
/*
时间：0ms，击败：100.00%
内存：7.3MB，击败：99.53%
*/