leetcode: Reverse Linked List II

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(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:

    void reverseList(ListNode* &node1, ListNode* &node2) {
        
        ListNode *pPreNode = NULL;
        ListNode *pCurNode = node1;
        ListNode *pNextNode = node1->next;
        
        while (pCurNode != node2)
        {
            pNextNode = pCurNode->next;
            pCurNode->next = pPreNode;
            
            pPreNode = pCurNode;
            pCurNode = pNextNode;
        }
        
        pCurNode->next = pPreNode;
    }

    ListNode *reverseBetween(ListNode *head, int m, int n) {
        
        ListNode fakeHead(0);
        ListNode *pPreNode = &fakeHead;
        ListNode *pCurNode = head;
        ListNode *pAfterNode;
        ListNode *pBeforeNode;
        
        pPreNode->next = pCurNode;
        
        ListNode *reverseN1;
        ListNode *reverseN2;
        
        int step = 1;
        
        while (step <= n && pCurNode)
        {
            if (step == m)
            {
                reverseN1 = pCurNode;
                pBeforeNode = pPreNode;
            }
                
            if (step == n)
            {
                reverseN2 = pCurNode;
                pAfterNode = pCurNode->next;
                break;
            }
            
            pPreNode = pPreNode->next;
            pCurNode = pCurNode->next;
            step++;
        }
        
        if (reverseN1 != reverseN2)
        {
            reverseList(reverseN1, reverseN2);
        }
        
        pBeforeNode->next = reverseN2;
        reverseN1->next = pAfterNode;
        
        return fakeHead.next;
    }
};