LeetCode中 翻转链表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.

大意是翻转部分或者全部代码：
我刚开始写的很乱，因为考虑很多边界问题，出了很多错，首先是如果m=n=1，也就是说m和n一样的情况。然后是m=1的情况，m=1就意味着没有前一个节点，需要分两种情况考虑。
总结一下我的思路：
1，首先找到要反转的那部分节点，我是通过num叠加找到的，记录这部分节点前一个节点pre，将这部分节点开始节点记为p，记录这部分节点后一个节点q。
2，将p和q输入到reverse函数，也就是倒转函数，利用3节点法。
3，融合链表，分情况考虑，第一，pre == NULL的情况，这时直接将head = reverse返回节点；第二，pre ！=NULL，那么pre->next = reverse返回节点。
这道题的难点在于边界情况很难想清楚，有点打脑袋。
代码如下：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/

class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        int num = 1;
        ListNode* pre = NULL;
        ListNode* cur = head;
        ListNode* p;
        ListNode* q;
        if(head == NULL && head->next == NULL)
        {
            return head;
        }
        while(num != m)
        {
            pre = cur;
            cur = cur->next;
            num++;
        }

        p = cur;

        while(num != n)
        {
            cur = cur->next;
            num++;
        }

        cur = cur->next;
        q = cur; //将q设置为下一个节点有好处，在反转时可以节约很多运算时间

        if(pre == NULL)
        {
            head = reverse(p , q);
            p->next = cur;
        }
        else
        {
           pre->next = reverse(p , q);
           p->next = cur;
        }
        return head;
    }

   ListNode* reverse(ListNode* head,ListNode* q) //翻转的思想很简单，就是3节点翻转思想，cur指向pre ，pre= cur，cur = next。另外不改变head有好处。
    {
        ListNode* pre = NULL;
        ListNode* cur = head;
        ListNode* next ;
        while(cur != q)
        {
            next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
};