3.链表中的节点每k个一组翻转

Q：将给出的链表中的节点每k个一组进行翻转，返回翻转后的链表；如果链表中的节点数不是k的倍数，将最后剩下的节点保持原样
A：大致思路为 翻转length/k轮；每轮翻转k-1次；每次翻转使用原地翻转的办法
1. 计算出链表的长度length
2. 计算出翻转的轮数a = length/k；
3. 定义虚拟头节点dummyNode，每次翻转区间的上一个节点pre，翻转区间的最左侧节点curr，最左侧节点的下一个节点temp
4. 双层for循环进行翻转，外层是翻转轮数，内层是每轮翻转次数
5. 进入外层循环
5.1 让curr节点为pre节点的下一个节点
5.2 进入内层循环
5.2.1 保存curr节点的下一个节点 temp = curr.next;
5.2.2 让当前节点指向temp节点的下一个节点 curr.next = temp.next
5.2.3 让temp节点指向pre的下一个节点（移动到最前） temp.next = pre.next
5.2.4 让pre节点指向temp节点 pre.next = temp
5.3 进入下一轮翻转前，让pre节点移动到下一个区间的前一节点 pre = curr；
6. 返回虚拟头节点的下一个节点

import java.util.*;
 
/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */
 
public class Solution {
    /**
     *
     * @param head ListNode类
     * @param k int整型
     * @return ListNode类
     */
    public ListNode reverseKGroup (ListNode head, int k) {
        // write code here
        ListNode t = head;
        int length = 0;
        while(t != null) {
            t = t.next;
            length++;
        }
 
        ListNode dummyNode = new ListNode(-1);
        dummyNode.next = head;
         
        //每个反转区间的前一个节点
        ListNode pre = dummyNode;
 
        ListNode curr = null, temp = null;
        //翻转a-1轮
        int a = length/k;
 
        for(int x=0; x<a; x++) {
             
            curr = pre.next;
 
            //每轮反转k-1次
            for (int y=1; y<k; y++) {
                temp = curr.next;
                curr.next = temp.next;
                temp.next = pre.next;
                pre.next = temp;
            }
 
            //下一次反转区间的前一个节点
            pre = curr;
        }
 
        return dummyNode.next;
    }
}