LC.92 | 反转链表 II | 链表 | 截断反转再拼接

输入： 单链表的头节点 head 和两个整数 left 和 right。

要求：反转从位置 left 到 right 的链表节点，并返回修改后的链表头节点。要求原地算法，空间复杂度为 $O(1)$，时间复杂度为 $O(n)$。

输出： 反转后的链表头节点。

---

思路：截断反转再拼接

这道题是 Lc.206 反转链表 的进阶版。一个非常清晰的思路是，我们不需要在原函数中重新实现反转逻辑，而是将问题拆解成我们已经解决过的子问题。

• 找到需要反转的子链表并将其从原链表中“截断”出来。
• 调用一个独立的函数（即 LC.206 的解法）来“反转”这个子链表。
• 将反转后的子链表重新“拼接”回原链表。

复杂度：

• 时间复杂度: $O(n)$
• 空间复杂度: $O(1)$

---

/**
 * 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:
    // LeetCode.206 的标准解法：头插法反转链表
    ListNode* reverseList(ListNode* head) {
        ListNode* dummy = new ListNode(0, NULL);
        ListNode* tmp;
        while (head) {
            tmp = head->next;
            head->next = dummy->next;
            dummy->next = head;
            head = tmp;
        }
        return dummy->next;
    }

    ListNode* reverseBetween(ListNode* head, int left, int right) {
        if (left == right) {
            return head;
        }
        ListNode* dummy = new ListNode(-1, head);
        ListNode* righthead = head;
        ListNode* lefthead = dummy; // lefthead 指向反转区域的前一个节点

        // 1. 定位
        // 让 lefthead 走到 left-1 的位置
        for (int i = 0; i < left - 1; ++i) {
            lefthead = lefthead->next;
        }
        // 让 righthead 走到 right 的位置
        for (int i = 0; i < right - 1; ++i) {
            righthead = righthead->next;
        }

        // 2. 截断
        ListNode* sub_list_head = lefthead->next; // 待反转子链表的头
        ListNode* rest_of_list = righthead->next; // 后续链表的头
        righthead->next = nullptr; // 断开

        // 3. 反转
        lefthead->next = reverseList(sub_list_head);

        // 4. 拼接
        // 此时 sub_list_head 已经变成了反转后的尾巴
        sub_list_head->next = rest_of_list;

        return dummy->next;
    }
};