链表--链表内指定区间反转

描述
将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)，空间复杂度 O(1)。
例如：
给出的链表为： 1→2→3→4→5→NULL,
m=2,n=4
返回：1→4→3→2→5→NULL.

数据范围： 链表长度 0 < size \le 1000 0<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
输入：
{1,2,3,4,5},2,4
返回值：
{1,4,3,2,5}

解题思路：首先将m到n段之间的链表截取下来，通过逆转链表进行逆转，然后在拼接到原来的链表上。
要注意的几个点： 1、设置头节点，方便进行查找
2、注意截取的链表的开始位置和结束位置，通过指针记录下来（如我用start记录需要转置的链表开始的前一个位置，end表示最后一个位置），方便转置完毕后进行拼接

public ListNode reverseBetween (ListNode head, int m, int n) {
        // write code here
         ListNode listNode=new ListNode(-1);//设置前置节点
        listNode.next=head;
        ListNode start=listNode;
        //找到m节点的前置节点作为截取的开始节点
        for(int i=0;i<m-1;i++){
            start=start.next;
        }
        ListNode log=start;
        ListNode end=start;
        //找到n节点，将后节点作为结束节点
        for(int i=m;i<=n;i++){
            end=end.next;
        }

        //获得m到n节点之间的链
        ListNode node=start.next;
        ListNode cut=end.next;

        //截取链
        start.next=null;
        end.next=null;
        //倒转
        ListNode reverse=ReverseList(node);
        //拼接起来
        log.next=reverse;
        ListNode sd=reverse;
        while (sd.next!=null){
            sd=sd.next;
        }
        sd.next=cut;
        return listNode.next;
    }
     public static ListNode ReverseList(ListNode head) {
        if (head==null){
            return null;
        }
        ListNode a=null;
        ListNode b=head;
        while(b!=null){
            ListNode c=b.next;
            b.next=a;
            a=b;
            b=c;
        }
        return a;
    }