LeetCode 25 Reverse Nodes in k-Group

心血来潮参加了一次比赛结果签到之后人没了，继续康复训练吧= =

做了一段时间的题，也看了一段时间别人更优的解法，思路很自然的变清晰了。

题意：给出一个链表的head和一个数值k，要求将链表里面每k个连续的node进行翻转，函数返回值为新的head。

思路：大体框架突出一个递归调用思想，既然每次返回新的head，就没有必要用循环结构来让指针指指指最后还指飞了，特判条件也很多。

于是考虑每k个点处理一次，先求next_head = reverseKGroup(now->next, k)，再处理好当前的k个点，将当前的head的next指向next_head并返回翻转后的new_head即可。

本来对于这个k个点也想要用递归来做的，但是考虑到优化空间复杂度到O(1)级别，直接用循环处理。

链表的处理无外乎记录一下cur和next两个点，不过由于这次需要将指针方向调转，需要一个中间变量tmp来记录next的位置，以免无法找到next->next。

对于一般情况而言，指针的记录状态如上图所示，但是注意cur->next这个指针，我在这里的做法是不对它进行维护，而是对于每一次的(cur,next)对，以next为中心来进行处理。这是因为对于边界情况，也就是head而言，其next指针需要指向的是next_head而不是之前与之紧邻的上一个点。

那么如上图中红色指针所示，对于循环过程中的每一个(cur,next)对，只需要进行红色指针的维护即可。

代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if (k == 1)
            return head;//boundary
        int sz = 1;
        ListNode* new_head = head;
        while(new_head != NULL){
            ++sz;
            new_head = new_head->next;
            if (sz == k)
                break;
        }
        if (new_head == NULL)
            return head;
        ListNode* new_next = reverseKGroup(new_head->next, k);
        ListNode* now = head, *tmp_next, *next;
        next = now->next;
        while(--sz){
            tmp_next = next->next;//temporary variant
            next->next = now;//reverse for *next
            now = next;//maintain the value of *cur
            next = tmp_next;//go to NEXT loop
        }
        head->next = new_next;//finished
        return new_head;
    }
};

1A了，爽到。