LeetCode No.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

====================================================================================
题目链接：https://leetcode.com/problems/reverse-nodes-in-k-group/
题目大意：将一个链表分成k个一组，并将每个含有k个元素的组翻转。（要求：不能修改节点的值，空间复杂度为O(1) ）
思路：如果这道题没有后面的要求就简单很多，每次记录下该组k个值，将值翻转后，然后扫一遍分别给各节点赋值就好了。但是既然题目这么要求，那就另想办法吧。
最好的办法是用递归，每次只需翻转第一组就行了，不断递归翻转，最后能得到正确结果。
现在我们就把这个大问题分解成一堆操作一样的小问题了，下面举例说明一下我的做法。
比如原来链表为：1->2->3->4->5->6->7
 和 k = 3
第一轮我们只需翻转前面k个就行了。
1、记录链表头priviousHead = head，这里链表头对应的数值为1，最后它还要指向4对应的节点
2、temp记录当前节点，pre记录temp->next，翻转之后pre就是temp的上一个节点
3、翻转操作
for ( int i = 1 ; i < k ; i ++ )
{
ListNode* t = pre ;
pre = pre -> next ;
t -> next = temp ;
temp = t ;
}4、递归调用
priviousHead -> next = reverseKGroup ( pre , k ) ;
5、重置链表头，即为temp
head = temp ;
附上代码：
/**
* 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) {
int n = 0 ;
ListNode* temp = head ;
ListNode* priviousHead = head ;
while ( temp )
{
n ++ ;
temp = temp -> next ;
}
if ( k <= 1 || k > n )
return head ;
temp = head ;
ListNode* pre = head -> next ;
for ( int i = 1 ; i < k ; i ++ )
{
ListNode* t = pre ;
pre = pre -> next ;
t -> next = temp ;
temp = t ;
}
priviousHead -> next = reverseKGroup ( pre , k ) ;
head = temp ;
return head ;
}
};