描述

将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)O(n)，空间复杂度 O(1)O(1)。

例如：

给出的链表为1→2→3→4→5→NULL, m=2, n=4。

返回1→4→3→2→5→NULL。

数据范围：链表长度 0 < size \le 10000<size≤1000，0 < m \le n \le size0<m≤n≤size，链表中每个节点的值满足 |val| \le 1000∣val∣≤1000 要求：时间复杂度 O(n)，空间复杂度 O(n) 进阶：时间复杂度 O(n)，空间复杂度 O(1)

示例1

输入： {1,2,3,4,5},2,4

返回值： {1,4,3,2,5}

示例2

输入： {5},1,1

返回值： {5}

题解：

这个题目很容易想到大致思路：把链表分成三份，part1-需反转部分-part2。遍历链表，找到m所在的节点的前一个节点，再遍历链表，找到n所在的节点。反转m-n范围内的链表，再把part1和反转之后的链表连接起来。

然而这样做有个需要注意的问题，如果m为1的话头节点的处理会很麻烦，所以我们可以采取虚拟头节点的方式来处理这个问题。

以下是我的解法：

/**
 * struct ListNode {
 *  int val;
 *  struct ListNode *next;
 *  ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param head ListNode类
     * @param m int整型
     * @param n int整型
     * @return ListNode类
     */
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        // write code here

        // 安全检查
        if (head == nullptr || head->next == nullptr || m == n) {
            return head;
        }

        auto dummyNode = new ListNode(-1);
        dummyNode->next = head;

        ListNode* p1 = dummyNode;
        for (int i = 1; i < m; i++) {
            p1 = p1->next;
        }
        // p1为m节点的前一个节点

        ListNode* p2 = head;
        for (int i = 1; i < n; i++) {
            p2 = p2->next;
        }
        // p2为n节点

        // 对该范围内的节点反转
        ListNode* pHead = p1->next;
        ListNode* beg = pHead;
        ListNode* end = beg->next;
        for (int i = 0; i < n - m; i++)
        {
            beg->next = end->next;
            end->next = pHead;
            pHead = end;
            end = beg->next;
        }

        p1->next = pHead;

        head = dummyNode->next;
        dummyNode->next = nullptr;
        delete dummyNode;
        
        return head;
    }
};