链表题目：反转链表 II

题目

标题和出处

标题：反转链表 II

出处：92. 反转链表 II

难度

4 级

题目描述

要求

给你单链表的头指针 $\text{head}$ 和两个整数 $\text{left}$ 和 $\text{right}$，其中 $\text{left}\le \text{right}$。请你反转从位置 $\text{left}$ 到位置 $\text{right}$ 的链表结点，返回反转后的链表。

示例

示例 1：

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

示例 2：

输入：$\text{head = [5], left = 1, right = 1}$
输出：$\text{[5]}$

数据范围

• 链表中结点数目为 $\text{n}$
• $\text{1}\le \text{n}\le \text{500}$
• $\text{-500}\le \text{Node.val}\le \text{500}$
• $\text{1}\le \text{left}\le \text{right}\le \text{n}$

进阶

你可以使用一次遍历完成反转吗？

解法一

思路和算法

这道题要求反转给定链表的从位置 $\text{left}$ 到位置 $\text{right}$ 的结点。可以定位到待反转的子链表，将其反转，然后将该子链表相邻的结点的指针指向更新，即完成了反转。

由于原始链表的头结点也可能在反转的范围内，因此需要创建哑结点 $\text{dummyHead}$，使得 $\text{dummyHead}.\text{next}=\text{head}$。从哑结点开始，分别向后移动 $\text{left}-1$ 次和 $\text{right}+1$ 次，定位到待反转的子链表的前一个结点 $\text{beforeReverse}$ 和待反转的子链表的后一个结点 $\text{afterReverse}$。

令 $\text{start}=\text{beforeReverse}.\text{next}$，则待反转的子链表为从 $\text{start}$ 开始的 $\text{right}-\text{left}+1$ 个结点。确定了待反转的子链表的范围之后，即可使用「反转链表」的做法，将子链表反转，反转时维护 $\text{prev}$ 和 $\text{curr}$，反转结束时，$\text{prev}$ 指向待反转的子链表的新的头结点。

完成子链表的反转之后，需要更新相邻结点的指针指向。将 $\text{prev}$ 接在 $\text{beforeReverse}$ 的后面，将 $\text{afterReverse}$ 接在 $\text{start}$ 的后面，则完成子链表的反转。

代码

class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        ListNode dummyHead = new ListNode(0, head);
        ListNode beforeReverse = dummyHead, afterReverse = dummyHead;
        for (int i = 1; i < left; i++) {
            beforeReverse = beforeReverse.next;
        }
        for (int i = 0; i <= right; i++) {
            afterReverse = afterReverse.next;
        }
        ListNode start = beforeReverse.next;
        ListNode prev = null, curr = start;
        for (int i = left; i <= right; i++) {
            ListNode next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        beforeReverse.next = prev;
        start.next = afterReverse;
        return dummyHead.next;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是链表的长度。需要遍历链表，定位到待反转的子链表然后反转，时间复杂度是 $O(n)$。

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

解法二

思路和算法

解法一需要遍历链表多次。如果要在一次遍历中完成反转，则需要使用头插法。

头插法的思想是：用 $\text{prev}$ 表示待反转的子链表的前一个结点，$\text{curr}$ 表示待反转的子链表的第一个结点，则每次将 $\text{curr}.\text{next}$ 插入到 $\text{prev}$ 的下一个结点。待反转的子链表共有 $\text{right}-\text{left}+1$ 个结点，除了 $\text{curr}$ 以外的每个结点都需要进行上述操作，因此一共进行 $\text{right}-\text{left}$ 次上述操作。

具体做法是，用 $\text{next}$ 表示 $\text{curr}$ 的后一个结点，依次进行如下三步操作：

1. 令 $\text{curr}.\text{next}$ 指向 $\text{next}$ 的后一个结点；

2. 令 $\text{next}.\text{next}$ 指向 $\text{prev}$ 的后一个结点；

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

在上述三步操作之后，$\text{prev}$ 不变，$\text{curr}$ 向后移动一个位置，$\text{next}$ 插入到 $\text{prev}$ 的后面一个位置。

在进行 $\text{right}-\text{left}$ 次上述操作之后，$\text{curr}$ 后面的 $\text{right}-\text{left}$ 个结点依次被插入到 $\text{prev}$ 的后面，完成反转。

下图为示例 1 的反转链表过程。灰色表示哑结点，蓝色表示待反转的子链表中的结点。

代码

class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        ListNode dummyHead = new ListNode(0, head);
        ListNode prev = dummyHead;
        for (int i = 1; i < left; i++) {
            prev = prev.next;
        }
        ListNode curr = prev.next;
        for (int i = left; i < right; i++) {
            ListNode next = curr.next;
            curr.next = next.next;
            next.next = prev.next;
            prev.next = next;
        }
        return dummyHead.next;
    }
}

复杂度分析

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

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