LeetCode OJ：Reverse Nodes in k-Group（K个K个的分割节点）

Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.

If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.

You may not alter the values in the nodes, only nodes itself may be changed.

Only constant memory is allowed.

For example,
Given this linked list: 1->2->3->4->5

For k = 2, you should return: 2->1->4->3->5

For k = 3, you should return: 3->2->1->4->5

k个k个的节点反转，即可，用到的记录节点可能比较多，写的比较乱，代码如下所示：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(k == 1) return head;
        if(!head || !head->next)
            return head;
        int len = 0;
        ListNode * p1 = head;
        while(p1){
            p1 = p1->next;
            len++;
        }
        //如果k比总长度还要长，那么直接返回即可
        if(len < k) return head;
        ListNode * prev = NULL;
        ListNode * curr = head;
        ListNode * tmpNode = NULL;
        ListNode * ret = new ListNode(-1);
        ListNode * helper = curr;
        ListNode * helperPre = NULL;
        while(len >= k){
            for(int i = 0; i < k; i++){//区域反转
                   tmpNode = curr->next;
                   curr->next = prev;
                   prev = curr;
                   curr = tmpNode;
            }
            if(!ret->next){//第一次手下记下的是首节点的位置
                ret->next = prev;
            }else{
                helperPre->next = prev;//以后将上一部分的尾节点连接到此部分的首节点上面
            }
            helper->next = curr;
            prev = helper;
            helper = curr;
            helperPre = prev;
            len -= k;
        }
        helperPre->next = curr;//将上次的尾节点域剩下的节点连接起来
        return ret->next;
    }
};