题解 | #链表内指定区间反转#

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

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

        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode prev = dummy;

        // 找到需要反转的起始位置的前一个节点
        for (int i = 0; i < m - 1 && prev != null; i++) {
            prev = prev.next;
        }

        if (prev == null || prev.next == null) {
            return head;
        }

        ListNode start = prev.next; // 反转区间的起始节点
        ListNode then = start.next; // 反转区间的下一个节点

        // 反转区间内的节点
        for (int i = 0; i < n - m; i++) {
            start.next = then.next;
            then.next = prev.next;
            prev.next = then;
            then = start.next;
        }

        return dummy.next;
    }
}

在Solution类中，我们实现了reverseBetween方法来反转链表的指定区间。首先，我们创建一个虚拟头结点dummy，指向原始链表头部。然后，我们找到需要反转的区间的起始位置的前一个节点prev。

接下来，我们定义两个指针start和then，分别指向反转区间的起始节点和起始节点的下一个节点。

通过迭代，将start节点的next指针指向then的下一个节点，然后将then节点的next指针指向prev的下一个节点，最后将prev节点的next指针指向then。循环直到完成区间内的节点反转。

最后，返回dummy的next作为反转后的链表头结点。时间复杂度为O(n)，空间复杂度为O(1)。