【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

题意：给你一个链表和正整数k，让链表每隔k个结点进行反转，最后若剩下不足k个结点，则不反转。

个人感觉这题难度是有一定的，想了很久，也没有能得到一个比较清晰的解法。于是网上搜索了下，得到了以下这一种方案，我觉得关键点有这么几点：

1）新建一个守护结点safeG，令其指向结点为head，然后定义三个ListNode指针pre，cur和post，分别指向safeG，head，head->next。接着循环cur和post结点。pre结点是用来反转完成后处理尾结点与后续结点的连接的。

2）若不足k个结点，则将反转后的结点重新反转，其中只需要先把cur和post指针调换即可，其余处理细节和1）相同。

3）处理完反转后，有以下几个步骤用来连接后续结点。

1.当前结点temp设为pre->next；

2.将pre->next设为cur；

3.将temp->next设为post；

4.将pre设为temp；

5.将cur设为post。

class Solution {
public:
    ListNode *reverseKGroup(ListNode *head, int k) {
        ListNode *safeG=new ListNode(-1);
        safeG->next=head;
        if(head==NULL||k==1)
            return head;
        ListNode *pre=safeG,*cur=head,*post=head->next;
        while(cur!=NULL)
        {
            post=cur->next;
            int i=0;
            while(i<k-1&&post!=NULL)
            {
                ListNode *temp=post->next;
                post->next=cur;
                cur=post;
                post=temp;
                i++;
            }
            if(i!=k-1)
            {
                int m=0;
                //交换cur,post结点
                ListNode *temp=post;
                post=cur;
                cur=temp;
                while(m<i)
                {
                    temp=post->next;
                    post->next=cur;
                    cur=post;
                    post=temp;
                    m++;
                }
                break;
            }
            ListNode *temp=pre->next;
            pre->next=cur;
            temp->next=post;
            pre=temp;
            cur=post;
        }
        head=safeG->next;
        delete safeG;
        return head;
    }
};