方法一：

思路与算法

根据题干，很容易可以联想到，使用递归地方式，只需要翻转链表的前 K 个元素，再将第 K 个元素的 next 指针，指向链表剩余节点反转后的结果即可。

既然使用递归，需要明确的是，递归的两个条件：
递归条件：链表的长度不小于 K 时，递归继续；
边界条件：链表的长度小于 K 时，递归结束，剩余节点不再翻转，直接拼到链表末尾。

值得说明的是，这里可以使用额外的方法来实时计算链表长度，以判断是否满足递归条件，但是这样无疑多进行了一次链表遍历，增加了算法的复杂度。比较巧妙的方法是，在移动指针指向第 k 个节点的过程中，如果当前节点已经为空了，说明链表的长度必定是小于 k 的，此时只需要直接返回头节点 head 即可。

翻转链表在 leetcode 中原题 206，考虑到题目要求只使用常量级别的额外空间，所以这里使用双指针法，实现翻转链表。

完整代码如下：

public class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        // 边界条件之一，节点为空时，不再反转
        if (head == null) return head;
        ListNode kthNode = head;
        for (int i = 0; i < k - 1; i++) {
            kthNode = kthNode.next;
            // 边界条件之二，节点长度小于 k 时，不再反转
            if (kthNode == null) return head;
        }
        // 反转前 k 个节点
        ListNode nextNode = kthNode.next;
        kthNode.next = null;
        ListNode reversedHead = reverse(head);
        ListNode reversedTail = reversedHead;
        while (reversedTail.next != null) {
            reversedTail = reversedTail.next;
        }
        // 并将第 k 个节点的 next 指针，指向剩余节点反转后的链表
        reversedTail.next = reverseKGroup(nextNode, k);
        return reversedHead;
    }

    /**
     * 翻转链表：
     *
     * dummyNode 作为新链表的哑节点，遍历原链表时，
     * 逐个将原链表的节点拼接到 dummyNode 的 next 指针，
     * 当原链表遍历完成后，dummyNode 的 next 节点
     * 就是反转后的新链表的头节点。
     *
     * @param head
     * @return
     */
    public ListNode reverse(ListNode head) {
        ListNode dummyNode = new ListNode(0);
        ListNode curr = head;
        while (curr != null) {
            ListNode currNext = curr.next;
            ListNode dummyNext = dummyNode.next;
            dummyNode.next = curr;
            curr.next = dummyNext;
            curr = currNext;
        }
        return dummyNode.next;
    }
}