LeetCode Reverse Nodes in k-Group

class Solution {
public:
    ListNode *reverseKGroup(ListNode *head, int k) {
        if (k < 1) return head;
        ListNode* last = NULL;
        ListNode* newhead = NULL;
        ListNode* cur = head;
        bool fullcut = false;
        while (cur != NULL) {
            ListNode* remain_head = cut(cur, k, fullcut);
            ListNode* rtail = cur;
            ListNode* rhead = fullcut ? reverse(cur) : cur;
            cur = remain_head;
            if (newhead == NULL) {
                newhead = rhead;
            } else {
                last->next = rhead;
            }
            last = rtail;
        }
        
        return newhead;
    }
    
    ListNode* cut(ListNode* head, int k, bool &full) {
        ListNode* cur = head;
        ListNode* pre = NULL;
        while (k > 0 && cur != NULL) {
            k--;
            pre = cur;
            cur = cur->next;
        }
        if (pre != NULL) pre->next = NULL;
        full = k == 0;
        return cur;
    }
    
    ListNode* reverse(ListNode* head) {
        ListNode* cur = head;
        ListNode* pre = NULL;
        while (cur != NULL) {
            ListNode* t = cur->next;
            cur->next = pre;
            pre = cur;
            cur = t;
        }
        return pre;
    }
};

对于是否完全是k个元素的处理有点脏（几个变量的含义与刚好是k个元素时不一致，不过因为不是k个的情况只会发生一次且是最后一次迭代，因而这些变量变脏了也无妨），不过时间有点长130ms+不知是否可以继续改进

第二轮：

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

强势回归！

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 // 20:24
class Solution {
public:
    ListNode *reverseKGroup(ListNode *head, int k) {
        ListNode dummyHead(0);
        dummyHead.next = head;
        
        ListNode* last_tail = &dummyHead;
        
        ListNode* pre = NULL;
        ListNode* cur = dummyHead.next;
        ListNode* rtail = cur;
        
        ListNode* prob = cur;
        
        int tk = k;
        while (prob != NULL && tk != 0) {
            prob = prob->next;
            tk--;
        }
        
        while (!tk) {
            while (cur != prob) {
                ListNode* tmp = cur->next;
                cur->next = pre;
                pre = cur;
                cur = tmp;
            }
            last_tail->next = pre;
            last_tail = rtail;
            
            last_tail->next = cur;
            rtail = cur;
            pre = NULL;
            
            tk = k;
            
            while (prob != NULL && tk != 0) {
                prob = prob->next;
                tk--;
            }
        }
        
        return dummyHead.next;
    }
};

 找到一个递归版本也挺好的：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 // recursive version: 20:53
class Solution {
public:
    ListNode *reverseKGroup(ListNode *head, int k) {
        ListNode* cur = head;
        int tk = k;
        while (tk && cur) {
            cur = cur->next;
            tk--;
        }
        
        if (!tk) {
            ListNode* pre = reverseKGroup(cur, k);
            cur = head;
            tk = k;
            while (tk--) {
                ListNode* tmp = cur->next;
                cur->next = pre;
                pre = cur;
                cur = tmp;
            }
            head = pre;
        }
        return head;
    }
};