【leetcode】25. K 个一组翻转链表

题目：25. K 个一组翻转链表 - 力扣（LeetCode） (leetcode-cn.com)

 

思路：

递归本质： 将问题划分成子问题，而子问题与问题有相同的算法逻辑和解决方案；

本题目可以划分成先以head开始的前k个节点进行反转，得到第k个节点后的结点b

剩下链表中的节点同样采取上述的操作,把结点b当作head，再对前k个结点反转；

假设递归函数reverseKGroup(ListNode head, int k)

下一次递归reverseKGroup(b,int k)

还需要找到base case： 即为剩余的链表已经不足k个节点，不需要反转，递归结束；

代码：

/**
 * 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 a,b;
        a = b = head;
        for(int i=0;i<k;i++){
            // 不足k个,不需要反转
            if(b == null) return head;
            b = b.next;
        }
        ListNode last = reverseAB(a,b);
        a.next = reverseKGroup(b,k);
        return last;
    }
    // 反转一个链表：迭代法
    public ListNode reverse(ListNode head){
        //前驱节点
        ListNode prev = null;
        // 当前节点
        ListNode curr = head;
        // 依次遍历各个结点，让其指向前一个结点
        while(curr != null){
            ListNode next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }
    // 反转一个链表[a,b)的部分：迭代法
    public ListNode reverseAB(ListNode a,ListNode b){
        //前驱节点
        ListNode prev = null;
        // 当前节点
        ListNode curr = a;
        // 依次遍历各个结点，让其指向前一个结点
        while(curr != b){
            ListNode next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }
}