25. K 个一组翻转链表

今天介绍一道 hard 级别的题目，学会了就不 hard
链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group

1 题目描述：

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

进阶：
你可以设计一个只使用常数额外空间的算法来解决此问题吗？
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例1

输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]

示例2

输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]

示例 3：

输入：head = [1,2,3,4,5], k = 1
输出：[1,2,3,4,5]

2 题目分析

这道题在反转链表的基础上，增加了分组、组内翻转、拼接链表，这几个内容。
有人说，掌握反转链表，这道题就不难。
我的个人感受是，分析过程不难，代码细节有很多。
过程大家都清楚了：给定一个单链表，每k个节点作为子链表，子链表内部要反转。链表末尾的几个节点如果不够k个，就不反转。

3 代码实现

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode dummyHead = new ListNode(0, head);

        ListNode pre = dummyHead;

        while (head != null) {
            
            ListNode tail = pre;

            //1 分组
            for (int i = 0 ; i < k; i++) {
                tail = tail.next;
                if (tail == null) {
                    // 提前结束
                    return dummyHead.next;
                }
            }

            ListNode nextGroupHead = tail.next  ; // 暂存下一组链表的头结点，待会用来拼接

            // 2 反转子链表
            ListNode[] nodes = reverse(head, tail);

            ListNode subListHead = nodes[0];
            ListNode subListTail = nodes[1];

            // 3 拼接回原来的链表
            pre.next = subListHead;  
            subListTail.next = nextGroupHead;
            
            pre = subListTail;   // 移动指针，然后开始下一轮循环
            head = nextGroupHead;

        }

        return dummyHead.next;
    }

    private ListNode[] reverse(ListNode head, ListNode tail) {
        tail.next = null;
        ListNode current = head;
        ListNode pre = null;
        while (current != null) {
            ListNode temp = current.next;
            current.next = pre;
            pre = current;
            current = temp;
        }
        return new ListNode[] {tail, head};
    }
    
}