25. K 个一组翻转链表

25. K 个一组翻转链表

给你一个链表，每 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]

示例 4：

输入：head = [1], k = 1
输出：[1]

提示：

• 列表中节点的数量在范围 sz 内
• 1 <= sz <= 5000
• 0 <= Node.val <= 1000
• 1 <= k <= sz

class Solution {
    // 倒转多个节点:创建一个pre的空结点，一个指向head的cur结点，一个指向下一个的next结点
    // 先标记next结点，记住。然后令cur指向pre。此时的结果为cur->pre(null). next->....
    // 还原情况：令pre为cur，cur为next即可。
    // 倒转两个节点：创建一个dump结点，一个front指向head，一个rear指向head.next.
    // dump指向rear，front指向rear.next，rear指向front即可。此时的结果为dump,rear,front.....
    // 所以为了还原情况，令dump为front，front为front.next,rear为front.next即可。
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode result = new ListNode(1, null);
        // p:循环，找出每一截需要改变顺序的链表.sign:记录是这一截中的第几个。
        ListNode front = head, rear = head, resultRear = result;
        int sign = 0;
        while(rear != null){
            ++sign;
            // 说明已经凑足一截了
            if(sign == k){
                // 令front取head，head取下一段的开始，截断操作。
                front = head;
                head = rear.next;
                rear.next = null;
                // 进行k - 1轮循环，类似完全1逆序的冒泡排序,每一轮进行k - 1 - i次修改
                front = reverse(front);
                // 结束以后，直接将返回的front插入到result的尾部，再重新遍历front，更新result尾部
                resultRear.next = front;
                while(front != null){
                    rear = front;
                    front = front.next;
                }
                resultRear = rear;
                // 令sign重新归零
                sign = 0;
                // 同时，令front和rear重新回到head
                rear = head;
                front = head;
            } else {
                rear = rear.next;
            }
        }
        // 说明有剩余内容
        if(sign != 0){
            resultRear.next = head;
        }
        return result.next;
    }

    public ListNode reverse(ListNode head){
        if(head == null || head.next == null){
            return head;
        }
        ListNode dump = null;
        ListNode front = dump, cur = head, rear;
        // 类似于头插法的思想，使整个链表倒转过来。
        while(cur != null){
            rear = cur.next;
            cur.next = front;
            front = cur;
            cur = rear;
        }
        return front;
    }
}