leetcode25---k组翻转链表-优快云博客

本文链接：https://blog.youkuaiyun.com/csdnnmbdybb/article/details/100015516

本文详细解析了如何使用递归方式解决LeetCode 206题的变种问题，即反转链表的前K个元素。通过分解问题，将大问题转化为多个小的反转问题，利用递归调用实现了链表的高效反转。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这题可以参考206的答案，事实上，我直接把翻转部分的代码用了leetcode206官方题解上面的，只是做了一点小修改，以保证是前K个反转；

我们具体分析核心函数 reverseKGroup;

一个关键是怎么把这个问题分解成好几个单独的翻转问题，我这里的reverseList函数做了改动，只反转前面K个节点，注意这个函数返回的是头结点，比如我反转 1->2->3 得到3->2->1,返回的是3这个节点，而1的下一个节点为null,所以我们每次都必须保存第K+1个节点，并把1的下一个节点赋值为递归处理的从第K+1个节点反转的结果；

这是一个递归的问题，我们反转1-2-3-4-5-6-7，可以想象，我们翻转了1-2-3，然后子问题4-5-6-7

即1-2-3-4-5-6-7；k=3;

我们第一轮反转1-2-3，并记录第K+1个节点，即4；

反转得到3-2-1，我们把1和剩下的节点反转得到的结果头结点连接起来，得到3-2-1

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        int count=0;
        ListNode head_copy=head;
        while(head_copy!=null&&count<k){
            // System.out.print(head_copy.val+"  ");
            count++;
            head_copy = head_copy.next;  //确保head_copy指向第k+1个node
        }
        if(count!=k)  //如果剩余的节点数小于k个，就不需要再处理了
            return head;
        else{
            // System.out.println("-------"+head_copy.val);           
            ListNode result=reverseList(head,k);
            // System.out.println("head.val-----"+head.val);
            // System.out.println("result.val-----"+result.val);
            head.next=reverseKGroup(head_copy,k);
            return result;
        }
    }
        public  ListNode reverseList(ListNode head,int k) {  //leetcode206
        ListNode prev = null;
        ListNode curr = head;
        int i=0;
        // k=4;
        while (curr != null&&i<k) {
            ListNode nextTemp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = nextTemp;
            i++;
        }
        return prev;
    } 
}