Reverse Nodes in k-Group

【LeetCode】

题目描述：

Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.

k is a positive integer and is less than or equal to the length of the linked 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 个结点的头尾和谁相连。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if(head == null || head.next == null || k < 2)
            return head;
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode begin = dummy;
        int i = 0;
        while(head != null){
            i++;
            if(i % k == 0){
                begin = reverse(begin, head.next);
                head = begin.next;
            }else
                head = head.next;
        }
        return dummy.next;
    }
    public ListNode reverse(ListNode begin, ListNode end){ // 反转（begin， end）开区间之间的 k 个结点
        ListNode prev = begin;
        ListNode curr = begin.next;
        ListNode first = curr;
        while(curr != end){
            ListNode next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        begin.next = prev;
        first.next = curr;
        return first;
    }
}

讨论区别人的递归版解法：还带注释的：

public ListNode reverseKGroup(ListNode head, int k) {
    ListNode curr = head;
    int count = 0;
    while (curr != null && count != k) { // find the k+1 node
        curr = curr.next;
        count++;
    }
    if (count == k) { // if k+1 node is found
        curr = reverseKGroup(curr, k); // reverse list with k+1 node as head
        // head - head-pointer to direct part, 
        // curr - head-pointer to reversed part;
        while (count-- > 0) { // reverse current k-group: 
            ListNode tmp = head.next; // tmp - next head in direct part
            head.next = curr; // preappending "direct" head to the reversed list 
            curr = head; // move head of reversed part to a new node
            head = tmp; // move "direct" head to the next node in direct part
        }
        head = curr;
    }
    return head;
}

 讨论区里别人的非递归版解法，16行，给跪了。。。

public ListNode reverseKGroup(ListNode head, int k) {
    int n = 0;
    for (ListNode i = head; i != null; n++, i = i.next);
    
    ListNode dmy = new ListNode(0);
    dmy.next = head;
    for(ListNode prev = dmy, tail = head; n >= k; n -= k) {
        for (int i = 1; i < k; i++) {
            ListNode next = tail.next.next;
            tail.next.next = prev.next;
            prev.next = tail.next;
            tail.next = next;
        }
        prev = tail;
        tail = tail.next;
    }
    return dmy.next;
}