BM2 链表内指定区间反转

描述

将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)O(n)，空间复杂度 O(1)。
例如：
给出的链表为 $1\to 2\to 3\to 4\to 5\to NULL$,$ m=2,n=4$,返回 $1\to 4\to 3\to 2\to 5\to NULL$.
数据范围： 链表长度0<size≤1000，0<m≤n≤size，链表中每个节点的值满足 $|val|\le 100$
要求：时间复杂度 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}

代码

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

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(m==n||head->next==NULL){
            return head;
        }
        ListNode* p=new ListNode(0);
        ListNode *first,*last,*mid;
        p->next=head;
        first=p;
        last=head;
        int i=1;
        while(last){
            if(i<m){
                first=first->next;
                last=last->next;
            }
            if(i==m){
                mid=last;
            }
            if(i>=m&&i<=n){
                ListNode *temp;
                temp=mid->next;
                mid->next=first->next;
                first->next=mid;
                mid=temp;
            }
            if(i>n){
                last->next=mid;
                break;
            }
            i++;
        }
        return p->next;
    }
};