一次没写出来的面试手撕

要实现按照 k 个一组反转链表的功能，
先将链表按每 k 个节点一组进行划分。
对每一组节点进行反转操作。
将反转后的组重新连接起来。

链表 1->2->3->4->5->6->7，
然后需要按照k个一组反转
比如k=2，那么需要得到2->1->4->3->6->5->7
k=3，得到3->2->1->6->5->4->7

```
// 定义链表节点类
class ListNode {
    int val;
    ListNode next;
    ListNode(int val) {
        this.val = val;
    }
}

public class ReverseNodesInKGroup {
    public ListNode reverseKGroup(ListNode head, int k) {
        if (head == null || k == 1) {
            return head;
        }
        // 创建一个虚拟头节点，方便处理
        ListNode dummy = new ListNode(0);
        dummy.next = head;

        ListNode prev = dummy;
        ListNode end = dummy;

        while (end.next != null) {
            // 找到当前组的最后一个节点
            for (int i = 0; i < k &amp;&amp; end != null; i++) {
                end = end.next;
            }
            if (end == null) {
                break;
            }
            ListNode start = prev.next;
            ListNode nextGroup = end.next;
            end.next = null;
            // 反转当前组的节点
            prev.next = reverseList(start);
            start.next = nextGroup;
            prev = start;
            end = start;
        }
        return dummy.next;
    }

    // 反转链表的方法
    private ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode current = head;
        while (current != null) {
            ListNode nextNode = current.next;
            current.next = prev;
            prev = current;
            current = nextNode;
        }
        return prev;
    }

    public static void main(String[] args) {
        // 创建链表 1->2->3->4->5->6->7
        ListNode head = new ListNode(1);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(3);
        ListNode node4 = new ListNode(4);
        ListNode node5 = new ListNode(5);
        ListNode node6 = new ListNode(6);
        ListNode node7 = new ListNode(7);

        head.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        node5.next = node6;
        node6.next = node7;

        ReverseNodesInKGroup solution = new ReverseNodesInKGroup();
        int k = 2;
        ListNode newHead = solution.reverseKGroup(head, k);

        // 打印反转后的链表
        while (newHead != null) {
            System.out.print(newHead.val);
            if (newHead.next != null) {
                System.out.print(&quot;->&quot;);
            }
            newHead = newHead.next;
        }
    }
}

```