Java 链表中节点每K个一组翻转

用 Java 实现链表中的节点每 K 个一组翻转。

1. 首先明白，每 K 个一组翻转，剩余长度不足的话则不翻转，所以我们首先应该求出链表的长度 length，然后通过 length - （length % K）求出我们需要翻转的链表的总长度。

2. 然后定义两个循环体，用外循环体控制我们需要翻转的链表的总长度，在内循环体1控制我们每一组需要进行翻转的链表。

3. 在外循环体内定义一个链表 temp，初始化为 null，然后用这个链表 temp 在内循环体1内接收每次翻转的一部分链表，然后每一次内循环1结束完到外循环又会初始化为 null，然后再接收，以此循环。

4. 在外循环外定义一个链表 result = new ListNode(0) ，定义一个 result2 = result，在外循环内，在内循环1结束之后，用 result.next = temp，以此来指向每个翻转的链表（长度为 K），然后创建一个内循环2，在内循环2内进行 K 次的 next，以此让 result 保持指向链表尾部。

5. 最后让 result 指向循环剩余的链表即可。

6. 返回result2.next 即可。
   代码如下：

    public ListNode reverseKGroup (ListNode head, int k) {
        // write code here
        ListNode node = head;
        int length = length(node);
        if (head == null) return null;
        if (k <= 0 || k > length) return head;
        int reversal = length - (length % k);
        int position = 0;
        ListNode result = new ListNode(0);
        ListNode result2 = result;
        ListNode local = null;
        for (position = 0; position < reversal;) {
            ListNode temp = null;
            for (int i = 0; i < k; i ++,position ++) {
                local = node.next;
                node.next = temp;
                temp = node;
                node = local;
            }
            result.next = temp;
            for (int j = 0; j < k; j ++) {
                result = result.next;
            }
   
        }
        result.next = node;
        return result2.next;
    }
   
    public int length(ListNode node) {
        int length = 0;
        while (node != null) {
            length ++;
            node = node.next;
        }
        return length;
    }