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

用了两个指针p1和p2，使得p1和p2相差k-1个位置。每次p1和p2区间reverse一下，然后再把同时更新p1和p2.

class Solution {
public:

    void reverse(ListNode *start, ListNode *end) {
        ListNode *pre = NULL, *tmp;
        while (start != end) {
            tmp = start->next;
            if (pre) start->next = pre;
            pre = start;
            start = tmp;
        }
        end->next = pre;
    }
    ListNode *reverseKGroup(ListNode *head, int k) {
            if (k <= 1) return head;
            ListNode *p1 = head, *p2 = head, *pre = NULL, *tmp;
            for (int i = 0; i < k - 1; ++i) {
                if (p1 == NULL) return head;
                p1 = p1->next;
            }
            if (p1 != NULL) head = p1;

            while (p1 != NULL) {
                tmp = p1->next;
                if (pre) pre->next = p1;
                reverse(p2, p1);
                pre = p2; // the tail of previous k-list
                p2 = p1 = tmp; // update p2
                for (int i = 0; i < k - 1; ++i) {
                    if (p1 == NULL) {
                        break; 
                    }
                    p1 = p1->next;
                }
                if (p1 == NULL) pre->next = tmp; // the left part is less than k
            }

            return head;
        }
};

一开始想一遍走完，边走边reverse，但是太复杂了，所以还是这样吧。。。

另一种思路，每次都找到第k个元素，迭代就行，不用这种两个指针的方法。写起来也比较简洁一点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void reverse(ListNode *&head, ListNode *&tail) {
        ListNode *prev = NULL, *p = head, *tmp;
        while (p) {
            tmp = p->next;
            p->next = prev;
            prev = p;
            p = tmp;
        }
        tail = head;
        head = prev;
    }
    
    ListNode *reverseKGroup(ListNode *head, int k) {
        if (head == NULL) return head;
        
        ListNode h(0), *cur = head, *next, *prev = &h, *p = head;
        h.next = head;
        
        while (cur) {
            p = cur;
            int i = 1;
            for (; i < k && p; p = p->next, i++);
            if (!p) break;
            next = p->next;
            p->next = NULL;
            reverse(cur, p);
            prev->next = cur;
            p->next = next;
            prev = p;
            cur = next;
        }
        
        return h.next;
    }

};