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

此题和Swap
Nodes in Pairs类似，只是这不再是swap 2个了，而变成K个一次；但是思路还是可以借鉴的，bnode用来只是当前段的前一个node, curStartNode用来表示当前段的起始位置，knode用来表示当前段的最后一个节点，这三个节点跟Swap
Nodes in Pairs一样的操作；除了操作这三个node之外，还需要将当前段整个的反转，这要用到Reverse
Linked List的做法，直接在用三个指针反转链表，这个反转也是一个curNode表示当前要反转的链表，curbnode表示curNode的前一个node, nextNode用来表示curNode的下一个节点，交换指针next可以实现就地反转;有了这两个操作之后，自然就可以很好的解决这个问题了。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
//类似于Swap Node in pairs，只是这里是swap k 个一次
ListNode* reverseKGroup(ListNode* head, int k) {
if(head == NULL)
return NULL;
if(k == 1)
return head;
ListNode *bNode = head, *knode = head, *curStartNode = head;
while(knode != NULL)
{
int count = 1;
while(knode != NULL && count < k)
{
knode = knode->next;
if(knode != NULL)
++count;
}

if(count == k)
{
//反转
ListNode *curbnode = curStartNode, *curNode = curStartNode->next, *nextNode = NULL;
while(curNode != knode)
{
nextNode = curNode->next;
curNode->next = curbnode;
curbnode = curNode;
curNode = nextNode;
}

//连接
curStartNode->next = knode->next;
knode->next = curbnode;
if(bNode == head)
{
head = knode;
}
else
{
bNode->next = knode;
}

bNode = curStartNode;
knode = bNode->next;
curStartNode = bNode->next;
}
}

return head;
}
};