25. 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

设置一个prehead ，cur = head，循环让cur的next 插入到 prehead 的next：

发现一个规律：！

A->next = B->next 并且 A在B前面的话  结果会使 B 脱离链表

/**
 * 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 || head == NULL) return head;
        ListNode dummy(-1);
        ListNode *prehead = &dummy, *pre = prehead, *cur = prehead, *nex;
        prehead->next = head;
        int n = 0;
        while(cur = cur->next) n++;//注意 cur的初始化
        while(n >= k){
            cur = pre->next;//注意 pre的初始化
            nex = cur->next;
            //注意cur只能向后移动k - 1次
            for(int i = 0; i < k - 1; i++){//有人说这里使用多余的空间 int i，而不是要求的常量空间，但是每次循环的上次循环已经释放了
                cur->next = nex->next;
                nex->next = pre->next;
                pre->next = nex;
                nex = cur->next;
            }
            pre = cur;//cur的val没变 但是位置已经向后移动过k - 1次，到达k个的最后一个
            n -= k;
        }
        return prehead->next;
    }
};