Reverse Nodes in k-Group

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    /*
     * 以k个节点为一组进行翻转,直到最末
     */
    ListNode* reverseKGroup(ListNode* head, int k) {
        if (NULL == head || 1 == k) {
            return head;
        }

        ListNode f(0);
        ListNode* node = &f;

        node->next = head;
        while (node && node->next) {
            ListNode* reverse_last;
            node->next = reverse(node->next, k, reverse_last);
            node = reverse_last;
        }
        return f.next;
    }
    /*
     * 翻转从p节点开始的k个节点
     * 如果失败,就返回初始节点p的位置, 并不进行翻转
     * 成功返回翻转后的开始节点
     * @param p 开始节点
     * @param k 翻转的节点个数
     * @param last 翻转成功后的第k个节点,如果翻转失败,该值为NULL
     * 
     */
    ListNode* reverse(ListNode* p, int k, ListNode* &last) {
        int m = k;
        ListNode* q = p;
        //这里做遍历,如果不满足条件,就保持原样
        while (m>1 && q){
            q = q->next;
            m--;
        }
        if (m>1 || NULL == q) {
            last = NULL;
            return p;
        }
        //进行翻转
        ListNode* pre = p;
        ListNode* c_node = p->next;
        ListNode* n_node = p->next->next;
        ListNode* q_next = q->next;
        while (pre != q) {
            c_node->next = pre;
            pre = c_node;
            c_node = n_node;
            n_node = n_node ? n_node->next : NULL;
        }
        p->next = q_next;
        last = p;
        return q;
    }

};