LeetCode--Reverse Nodes in k-Group

题意：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

题解：首先求出链表的长度，能交换则我们使用一系列指针完成交换。
交换的过程主要是将非头节点的节点依次放到group的头部。
eg：最初是1->2->3->4 ,k = 4
1. 将2移到最前面，即2->1->3->4
2. 将3移到最前面，即3->2->1->4
3. 将4移到最前面，即4->3->2->1
注意到1始终是我们需要移动的节点的前一节点，且最后到达group尾部。

代码如下：

class Solution {
public:
    ListNode *reverseKGroup(ListNode *head, int k) {
        if(k <= 1)
            return head;
        int listLen = 0;    //链表长度
        ListNode* reverseNode;  //指向group需要提前到头部的节点
        ListNode* reverseNode_prev; //reverseNode的前一节点
        ListNode* groupHead_prev;   //指向group的前一个节点
        ListNode* head_prev = new ListNode(0);  //指向链表头的前一个节点
        head_prev->next = head;
        ListNode* tmp = head;
        while(tmp){
            listLen++;
            tmp = tmp->next;
        }
        reverseNode_prev = head_prev;
        /*
        reverseNode_prev在交换过程中会一直指向交换之前的group头，
        即交换完以后，头变尾，指针就会指向此group的尾。 
        */ 
        while(listLen >= k){
            groupHead_prev = reverseNode_prev;
            //将上一group的尾赋给即将交换的group的头的上一个节点 
            reverseNode_prev = groupHead_prev->next;
            //将即将交换的group头赋给reverseNode_prev
            int reverseLen = k-1;
            while(reverseLen--){
                reverseNode = reverseNode_prev->next;
                //将reverseNode移到group头 
                reverseNode_prev->next = reverseNode->next;
                reverseNode->next = groupHead_prev->next;
                groupHead_prev->next = reverseNode;
            }
            listLen -= k;
        }
        return head_prev->next;
    }
};