链表内指定区间反转

题意：

将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)O(n)，空间复杂度 O(1)O(1)。
例如：
给出的链表为 1\to 2 \to 3 \to 4 \to 5 \to NULL1→2→3→4→5→NULL, m=2,n=4m=2,n=4,
返回 1\to 4\to 3\to 2\to 5\to NULL1→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(n)

进阶：时间复杂度 O(n)O(n)，空间复杂度 O(1)O(1)

示例：

输入：

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

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

{5},1,1
返回值：

{5}

题解：首先把m-n区间内的节点改变指向，然后让首尾反转即原本指向区间首节点现在指向尾节点，区间首节点指向遍历的下一个节点。注意：需要添加一个虚拟首节点，如示例2。

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

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
        int s=0;
        ListNode h=new ListNode(-1);
        ListNode left=null,right=null,pre=null,next=null;
        h.next=head;
        head=h;
     if(m==n)
         return head.next;
        while(h!=null)
        {
            next=h.next;
            
            if(s==m-1)
                left=h;
            if(s>=m&&s<n)
            {
                if(s==m)
                    right=h;
                h.next=pre;
                pre=h;
            }
            if(s==n)
            {
                h.next=pre;
                left.next=h;
                right.next=next;
                
            }
            h=next;
            s++;
        }
        
          head=head.next;
        return  head;
    }
}