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.

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個結點，並傳回下一組的前一結點”這個事情。 主函數中就不斷回調這個方法，直到最後傳回的是null即可。

子函數中做三個事情。1.確認有沒有k個非空結點可以操作，沒有的話就不動直接傳回null。 2.改變n1 ~ nk這k個節點的指針指到前面的結點去（四句頂真）。3.改變before 和n1這兩個結點的next指針，完善頭尾接龍。

細節：1.主函數用dummy node，之後直接返回dummy.next即可，因為調用函數後是整個鏈表的結構就改變了，自動next也變了。 2.這種比較復雜的鏈表變動最好一開始在子函數前面用註釋寫好你的結構是怎麽變動的，用於寫的過程中指導。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 
 
*/


public class Solution {
    /*
     * @param head: a ListNode
     * @param k: An integer
     * @return: a ListNode
     */
    public ListNode reverseKGroup(ListNode head, int k) {
        // write your code here
        ListNode dummy = new ListNode(0);
        dummy.next = head;

        ListNode prev = dummy;
        while (prev != null) {
            prev = reverseOneGroup(prev, k);
        }
        return dummy.next;
    }
    
    // before -> n1 -> n2 -> ... -> nk-1 -> nk -> nk+1
    // =>
    // before -> nk -> nk-1 -> ... -> n2 -> n1 -> nk+1
    private ListNode reverseOneGroup(ListNode before, int k) {
        
        // check there are k nodes
        ListNode prev = before;
        for (int i = 0; i < k; i++) {
            prev = prev.next;
            if (prev == null) {
                return null;
            }
        }
        
        // change n1 ~ nk‘s pointers
        prev = before;
        ListNode crt = before.next;
        for (int i = 0; i < k; i++) {
            ListNode temp = crt.next;
            crt.next = prev;
            prev = crt;
            crt = temp;
        }
        
        // before <-> n1 <- n2 <- ... <- nk-1 <- nk  nk+1
        // =>
        // before -> nk -> nk-1 -> ... -> n2 -> n1 -> nk+1 
        ListNode n1 = before.next;
        ListNode nk = prev;
        ListNode nkplus = crt;
        before.next = nk;
        n1.next = nkplus;
        
        return n1;
    }
}

leetcode450- Reverse Nodes in k-Group- hard