LeetCode OJ | #25 Reverse Nodes in k-Group

考试前刷一波leetcode。
这次的问题依然是简单的，但是处理方式极为麻烦，因为涉及到了单向链表的反转操作。C++有个规律：一旦涉及到指针和链表的东西，绝对会有无数的边界情况和细节在等着你。
先上题：
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
那么问题来了，我先是使用了最暴力的方法：直接从头开始，一个一个的把链表的next接到下下个链表块里，也就是说假设a->b->c，那么我就把a->next接到c上，再把b->next接到a上。
然而事实证明这种方法绝对是耗费太大又蠢到家，因为结果是TLE。
于是乎，我就直接来更暴力的方法。因为题中要求常数空间复杂度，那么我就干脆一次存三个块，直接把b的next接到a上，同时，因为c已经被我存在一个变量里了，所以c不会丢失。然后，就是很清楚的事了：先往前探索k个块，看是否能满足有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)
{
ListNode * a = NULL;
ListNode * tmp = NULL;
ListNode * header = NULL;
ListNode * t1 = NULL;
ListNode * result = NULL;
ListNode * rear = NULL;
int time = 0;
int i = 0;
if(k==1) return head;
while(head!=NULL)
{
i = 0;
header = head;
a = head->next;
while(i<k-1 && header->next!=NULL)
{
header = header->next;
++i;
}
if(i == k-1)
{
t1 = head;
head->next = header->next;
if(rear!=NULL) rear->next = header;
rear = head;
head = head->next;
for(int j=0;j<k-1;++j)
{
tmp = a->next;
a->next = t1;
t1 = a;
a = tmp;
}
}
if(i<k-1)
{
if(time == 0)
result = head;
break;
}
if(time == 0) result = header;
++time;
}
return result;
}
};