方法一：分块翻转

• 将链表分块，每块的长度为k个元素,分块翻转。
• 首先，计算链表长度，根据链表长度和k计算需要翻转多少块；
• 之后，一块一块的翻转；
• 最后，再将长度不足k的块接到翻转后的链表尾部。

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
        if(head == null || k <= 1)
            return head;
        
        // 获取链表长度
        int len = getLength(head);
        // 分块
        int blocks = len / k; //都是int类型，向下取整
        ListNode result = new ListNode(-1);
        ListNode resultTail = result;
        // 一块一块的翻转
        ListNode cur = head;
        for(int i = 0; i < blocks; ++i){
            // 翻转第i+1个块
            ListNode pre = null;
            for(int j = 0; j < k; ++j){
                ListNode tmp = cur.next;
                cur.next = pre;
                pre = cur;
                cur = tmp;
            }
            // 翻转后，pre为当前块的第一个节点,cur为新的块的第一个节点
            resultTail.next = pre; // 接到结果链表尾部
            while(resultTail.next != null)
                resultTail = resultTail.next; // 指向结果链表的尾节点
        }
        resultTail.next = cur; // 将长度不足k的最后一块接上
        return result.next;
    }
    
    private int getLength(ListNode list){
        ListNode cur = list;
        int len = 0;
        while(cur != null){
            len++;
            cur = cur.next;
        }
        return len;
    }
}

方法二：栈

• 翻转问题：可以考虑用栈的后入先出的特点来解决；
• 以k为单位，将元素入栈，之后以k为单位出栈，并将出栈的元素拼接到链表尾部；
• 最后，将不足k个的元素接到链表尾部

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
        if(head == null || k <= 1)
            return head;
        
        Deque<ListNode> stack = new ArrayDeque<>(); 
        ListNode result = new ListNode(-1);
        ListNode resultTail = result;
        ListNode cur = head;
        while(true){
            int count = 0;
            for(int i = 0; i < k; ++i){ // 每k个为一组，入栈
                stack.offerLast(cur);
                count++;
                cur = cur.next;
                if(cur == null) // 遍历结束
                    break;  // 跳出for
            }
            if(count == k){ // k个元素出栈，拼接到链表尾部
                while(!stack.isEmpty()){
                    resultTail.next = stack.pollLast();
                    resultTail = resultTail.next;
                    resultTail.next = null;
                }
            }
            if(cur == null) break; //跳出break;
        }
        while(!stack.isEmpty()){ // 不足k个的元素，接到链表尾部
            cur = stack.pollLast();
        }
        resultTail.next = cur;
        return result.next;
    }
}