链表题目：两两交换链表中的结点

题目

标题和出处

标题：两两交换链表中的结点

出处：24. 两两交换链表中的结点

难度

4 级

题目描述

要求

给定一个链表，两两交换其中相邻的结点，并返回交换后的链表。不能修改结点的值，只能修改结点本身。

示例

示例 1：

输入：$\text{head = [1,2,3,4]}$
输出：$\text{[2,1,4,3]}$

示例 2：

输入：$\text{head = []}$
输出：$\text{[]}$

示例 3：

输入：$\text{head = [1]}$
输出：$\text{[1]}$

数据范围

• 链表中结点的数目范围是 $\text{[0, 100]}$
• $\text{0}\le \text{Node.val}\le \text{100}$

解法一

思路和算法

可以使用递归的方法交换链表中的每对相邻结点。

如果链表中的结点数量少于 $2$，则不需要做任何交换，原始链表即为结果，因此递归的终止条件是链表为空或者只有 $1$ 个结点，此时返回原始链表。

如果链表中的结点数量大于或等于 $2$，则使用递归的方法完成结点的交换。首先将除了前两个结点以外的部分完成交换，然后更改前两个结点的 $\text{next}$ 指针的指向，即可完成整个链表的结点的交换。

原始链表的头结点为 $\text{head}$，第二个结点为 $\text{head}.\text{next}$，在交换结点之后，原始链表的第二个结点变成新链表的头结点，令 $\text{newHead}=\text{head}.\text{next}$。递归交换结点的具体做法如下：

1. 对 $\text{newHead}.\text{next}$ 调用递归，将除了前两个结点以外的部分完成交换；

2. 令 $\text{head}.\text{next}$ 指向递归调用之后返回的头结点；

3. 令 $\text{newHead}.\text{next}$ 指向 $\text{head}$。

在上述操作之后，$\text{newHead}$ 变成新链表的头结点，$\text{head}$ 变成新链表的第二个结点，其余结点在递归调用中完成交换，因此整个链表的结点完成交换，返回 $\text{newHead}$。

代码

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)$，其中 $n$ 是链表的长度。需要对链表的每个结点进行更新指针的操作，每个结点的更新指针操作的时间都是 $O(1)$。

• 空间复杂度：$O(n)$，其中 $n$ 是链表的长度。空间复杂度主要取决于递归调用栈的深度，递归调用栈最多不会超过 $n$ 层。

解法二

思路和算法

也可以使用迭代的方法交换链表中的每对相邻结点。

由于新链表的头结点和原始链表的头结点不同，因此需要创建哑节点 $\text{dummyHead}$，使得 $\text{dummyHead}.\text{next}=\text{head}$。用 $\text{temp}$ 表示当前所在的结点，初始时 $\text{temp}=\text{dummyHead}$。当 $\text{temp}$ 的后面至少有 $2$ 个结点时，交换 $\text{temp}$ 的后面 $2$ 个结点，然后将 $\text{temp}$ 向后移动 $2$ 步，直到 $\text{temp}$ 到达链表的最后 $2$ 个结点。

当 $\text{temp}$ 的后面至少有 $2$ 个结点时，假设 $\text{temp}$ 后面的 $2$ 个结点依次是 ${\text{node}}_1$ 和 ${\text{node}}_2$，即结点顺序为 $\text{temp}\to {\text{node}}_1\to {\text{node}}_2$，则需要交换 ${\text{node}}_1$ 和 ${\text{node}}_2$，交换后的结点顺序为 $\text{temp}\to {\text{node}}_2\to {\text{node}}_1$。

为了交换 ${\text{node}}_1$ 和 ${\text{node}}_2$，需要依次进行以下操作：

1. 将 $\text{temp}.\text{next}$ 指向 ${\text{node}}_2$；

2. 将 ${\text{node}}_1.\text{next}$ 指向 ${\text{node}}_2.\text{next}$；

3. 将 ${\text{node}}_2.\text{next}$ 指向 ${\text{node}}_1$。

在上述操作之后，${\text{node}}_1$ 为 $\text{temp}$ 后面的第 $2$ 个结点，将 $\text{temp}$ 移动到 ${\text{node}}_1$，继续对剩余的结点进行交换，直到整个链表的结点交换结束。

整个链表的结点完成交换之后，返回 $\text{dummyHead}.\text{next}$。

下图为交换链表中的每对相邻结点的例子，图中的灰色结点表示哑节点。

代码

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummyHead = new ListNode(0, head);
        ListNode temp = dummyHead;
        while (temp.next != null && temp.next.next != null) {
            ListNode node1 = temp.next;
            ListNode node2 = temp.next.next;
            temp.next = node2;
            node1.next = node2.next;
            node2.next = node1;
            temp = node1;
        }
        return dummyHead.next;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是链表的长度。需要遍历链表中的每个结点一次，每个结点的反转操作的时间都是 $O(1)$。

• 空间复杂度：$O(1)$。