算法经典题：链表内指定区间反转

NC21 链表内指定区间反转

描述

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

数据范围： 链表长度0<size≤1000，0<m≤n≤size，链表中每个节点的值满足0≤∣val∣≤1000

要求：时间复杂度，空间复杂度

进阶：时间复杂度，空间复杂度

思路：使用虚拟节点指向头节点，循环找到需要反转的子链表的头尾节点的前一个位置。将之与原链表断开，将该子链表反转。反转后再将其拼接上即可。

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 index = 0;
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode pre = dummy;
        ListNode p1 = null, p2 = null;
        while(pre != null) {
            if(index + 1 == m) {
                p1 = pre;
            }
            if(index + 1 == n) {
                p2 = pre;
                break;
            }
            index++;
            pre = pre.next;
        }
        ListNode p3 = p2.next.next;
//         System.out.println(p1.val + " " + p2.val);
        p2.next.next = null;
        p1.next = rev(p1.next);
        pre = dummy;
        while(pre.next != null) {
            pre = pre.next;
        }
        pre.next = p3;
        return dummy.next;
    }
    
    public ListNode rev(ListNode head) {
        ListNode pre = head, cur = head.next;
        head.next = null;
        while(cur != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
}