【leetcode】 24 两两交换链表中的节点

解法一：递归

思路

题目给出了单向链表的定义：

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) {}
};

将整个单向链表两两交换相邻的节点，可看成重复执行：

完成剩余的rest部分的节点交换，将head的next指向交换好的rest，再将newHead的next指向head。最终返回newHead。

步骤

1. 递归终止条件：当链表中只剩一个节点或没有节点，便无需再交换

2. 创建ListNode型指针newHead，newHead = head->next

3. 对rest部分链表进行递归，rest部分链表头是newHead->next，调用swapPairs(newHead->next)，swapPairs的返回值是新链表头，让head->next指向swapPairs(newHead->next)

4. newHead->next = head

5. 返回新链表头newHead

代码

/**
 * 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 == NULL || head->next == NULL) return head;

        ListNode* newHead = head->next;
        head->next = swapPairs(newHead->next);
        newHead->next = head;

        return newHead;
    }
};

分析

时间复杂度：O(n)

空间复杂度：O(n)

 

解法二：迭代

思路

将单向链表中的相邻两个节点全部进行交换，可以每次将其中一对相邻节点进行交换，如下图中先交换第1个节点和第2个节点，再交换第3个节点和第4个节点，直至全部节点交换完毕：

需要反复迭代的操作是：tmp的下一个节点从node1变为node2，node1的下一个节点从node2变为node2->next，node2的下一个节点变为node1，再将tmp挪到node1。继续迭代，直至tmp后面只有一个节点或没有节点为止。

步骤

1. 创建head的前置节点dummyHead，它是tmp节点的初始化节点。（为将两次迭代的成对节点关联起来，引入tmp节点）

2. while循环条件为tmp后面紧跟至少俩节点：tmp->next != NULL && tmp->next->next != NULL

3. while循环体内进行两两互换：

    tmp->next = node2;

    node1->next = node2->next;

    node2->next = node1;

    最终别忘了将tmp重新挪到node1的位置：

    tmp = node1;

4. while循环迭代结束后，链表中全部节点完成相邻节点的两两互换，返回链表头dummyHead.next即可。

代码

/**
 * 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) {
        ListNode dummyHead = ListNode();
        dummyHead.next = head;
        ListNode* tmp = &dummyHead;

        while (tmp->next != NULL && tmp->next->next != NULL) {
            ListNode* node1 = tmp->next;
            ListNode* node2 = tmp->next->next;
            
            tmp->next = node2;
            node1->next = node2->next;
            node2->next = node1;

            tmp = node1;
        }

        return dummyHead.next;
    }
};

注意：struct和指针的使用细节。

分析

时间复杂度：O(n)

空间复杂度：O(1)