[leetcode]92. Reverse Linked List II

题目链接：https://leetcode.com/problems/reverse-linked-list-ii/#/description

Reverse a linked list from position m to n. Do it in-place and in one-pass.

For example:
Given 1->2->3->4->5->NULL, m = 2 and n = 4,

return 1->4->3->2->5->NULL.

Note:
Given m, n satisfy the following condition:
1 ≤ m ≤ n ≤ length of list.

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        ListNode* new_head = new ListNode(-1);
        new_head->next = head;
        ListNode* left_prev;
        ListNode* left_cur; 
        ListNode* right_cur;
        ListNode* right_next;
        
        ListNode* p = new_head;
        for(int i = 0; i< left - 1; i++) {
            p = p->next;
        }
        left_prev = p;
        left_cur = p->next;
        for(int i = left- 1; i <right; i++) {
            p =p->next;
        }
        right_cur = p;
        right_next= p->next;

        ListNode* t = reverse(left_cur, right_next);
        left_prev->next = t;
        left_cur->next = right_next;

        return new_head->next;
    }

    ListNode* reverse(ListNode* head, ListNode* tail) {
        ListNode* new_head = new ListNode(-1);

        ListNode* p = head;
        while(p!=tail) {
            ListNode* t = p;
            p=p->next;
            t->next= new_head->next;
            new_head->next=t;
        }

        return new_head->next;
    }
};

class Solution{
public:
    ListNode* reverseBetween(ListNode* head,int m,int n)
    {
        ListNode * new_head=new ListNode(-1);
        new_head->next=head;
        ListNode* pre=new_head;
        for(int i=0;i<m-1;i++)
            pre=pre->next;
        ListNode* cur=pre->next;
        for(int i=0;i<n-m;i++)
        {
            ListNode* move=cur->next;
            cur->next=move->next;
            move->next=pre->next;
            pre->next=move;
        }
        return new_head->next;
    }
};