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 ＝ 1的时候，也是返回原来链表，要注意程序中两次注释中出错的地方

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if (head == null ||k <= 1 ) {
            return head;
        } 
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode beforeStart = dummy;
        ListNode start = head;
        ListNode end = head;
        ListNode afterEnd = end.next; 
        int count = 1;
        while(end != null) {
            if (count == k) {
                afterEnd = end.next;
                reverse(start, end);
                beforeStart.next = end;
                beforeStart = start;
                //要把start.next 设为 afterEnd, 之前漏掉这一步，出错
                start.next = afterEnd;
                end = start;
                start = afterEnd;
                count = 0;
            }
            end = end.next;
            count++;
        }
        return dummy.next;
    }
    void reverse(ListNode start, ListNode end) {
        ListNode dummy = new ListNode(-1);
        dummy.next = start;
        ListNode pre = dummy;
        ListNode cur = dummy.next;
        ListNode next = cur.next;
        //这里要考虑如果end.next == null,那么下面循环中next.next 就会有空指针错误，
        //所以这里把要转换的最后一个node，也就是end， 单独拿出来转换
        while(next != end.next) {
            cur.next = pre;
            pre = cur;
            cur = next;
            next = next.next;
        }
        cur.next = pre;
    }
}

别人的解法：
这里是先计算出了 链表中有几个k，则有几次转换，我上面的写法比这种方法只少了一次循环，时间复杂度是一样的，都是o(n)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if (head == null ||k <= 1 ) {
            return head;
        } 
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode beforeStart = dummy;
        ListNode start = head;
        ListNode end = head;
        ListNode afterEnd = end.next; 
        int count = 1;
        while(end != null) {
            if (count == k) {
                afterEnd = end.next;
                reverse(start, end);
                beforeStart.next = end;
                beforeStart = start;
                //要把start.next 设为 afterEnd, 之前漏掉这一步，出错
                start.next = afterEnd;
                end = start;
                start = afterEnd;
                count = 0;
            }
            end = end.next;
            count++;
        }
        return dummy.next;
    }
    void reverse(ListNode start, ListNode end) {
        ListNode dummy = new ListNode(-1);
        dummy.next = start;
        ListNode pre = dummy;
        ListNode cur = dummy.next;
        ListNode next = cur.next;
        //这里要考虑如果end.next == null,那么下面循环中next.next 就会有空指针错误，
        //所以这里把要转换的最后一个node，也就是end， 单独拿出来转换
        while(next != end.next) {
            cur.next = pre;
            pre = cur;
            cur = next;
            next = next.next;
        }
        cur.next = pre;
    }
}