高频6. K 个一组翻转链表 及其变形题的各种解法 Java codetop 递归

题目描述

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]

各种解法

前面的逻辑相同，取出k个元素之后，对它的翻转可以使用 递归 解法，也可以使用 迭代 解法。每一组的翻转可以参考翻转链表的多种解法

class Solution {
    public ListNode reverseKGroup(ListNode head, int k){
        if(head == null) return head;
        ListNode a, b;
        a = b = head;
        // 处理不足k个的情况，base case
        for(int i=0; i<k; i++){
            if(b == null) return head; // 如果最后也要反转，在此用reverse
            b = b.next;
        }
        // 反转前k个元素的结果
        ListNode newHead = reverse(a,b);
        // 递归反转后续链表并连接起来
        a.next = reverseKGroup(b,k);
        return newHead;
    }
    // 每个组内部进行反转，左闭右开，右是第k+1个元素
    public ListNode reverse(ListNode a, ListNode b){
        ListNode pre = null, cur = a;
        while(cur != b){
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
    // 递归翻转，b就相当于原来的null
    // public ListNode reverse(ListNode a, ListNode b){
    //     if(a == b || a.next == b) return a;
    //     ListNode newHead = reverse(a.next, b);
    //     a.next.next = a;
    //     a.next = b;
    //     return newHead;
    // }
}

解题思路

• 整体是reverseKGroup这个递归，当中嵌套了reverse，reverse的实现既可以是递归又可以是迭代。
• 用 a, b 两个指针都指向head，首先处理链表不足k个的情况，使用 b 指针后移，意味着b 会为null，此时题目要求不动。如果此处要进行后续变形题中要求的【不足k个也要翻转】。只需要在此处不是返回head，而是调用reverse(a,b)，对a到b之间进行翻转。
• 新的头结点，就是第一组翻转后的结果，原来的a指针就随原来的head一起，翻转到最后了，刚好可以用来连接递归翻转后续链表的结果。

变形题

1. K个一组翻转链表，不足k个也要翻转

class Solution {
    public ListNode reverseKGroup(ListNode head, int k){
        if(head == null) return head;
        ListNode a, b;
        a = b = head;
        // 处理不足k个的情况，base case
        for(int i=0; i<k; i++){
            if(b == null) return reverse(a,b); // 【此处进行了不足k个情况的翻转】
            b = b.next;
        }
        // 反转前k个元素的结果
        ListNode newHead = reverse(a,b);
        // 递归反转后续链表并连接起来
        a.next = reverseKGroup(b,k);
        return newHead;
    }
    // 每个组内部进行反转，左闭右开，右是第k+1个元素
    public ListNode reverse(ListNode a, ListNode b){
        ListNode pre = null, cur = a;
        while(cur != b){
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
}

不足k个情况的翻转，原先return head，现在调用reverse(a,b)，返回翻转的结果。