【LeetCode】反转链表（递归法）

本篇的姊妹篇——迭代法：【LeetCode】反转链表（迭代法）【算法模版，一招吃遍天下鲜】-CSDN博客

老规矩，从易到难掌握反转链表的递归法，首先关于递归的最基础理解，建议可以先去看下《算法图解》这本书，不搞什么高大上的，就最简单易懂朴素原始的方式感受下递归是怎么个事（ps.我觉得开篇那个盒子套盒子的例子反而挺抽象不太好理解，不明白就接着往下看）。然后，上代码。

俺不敢说百分百弄懂递归法，但悟出来一个领悟的要点就是一定要去画递归栈，找出来基准条件和递归条件，结束递归的条件下的return就是标志着元素开始出栈。

LC206（从头到尾反转整个链表）

. - 力扣（LeetCode）

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode last = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return last;
    }
}

反转链表前 N 个节点

class Solution {
    ListNode successor = null; // 后驱节点

    // 反转以 head 为起点的 n 个节点，返回新的头结点
    ListNode reverseN(ListNode head, int n) {
        if (n == 1) { 
            // 记录第 n + 1 个节点
            successor = head.next;
            return head;
        }
        // 以 head.next 为起点，需要反转前 n - 1 个节点
        ListNode last = reverseN(head.next, n - 1);

        head.next.next = head;
        // 让反转之后的 head 节点和后面的节点连起来
        head.next = successor;
        return last;
    }
}
  

LC92（反转指定左右指针间的链表）

. - 力扣（LeetCode）

class Solution {
    ListNode successor = null; // 后驱节点

    ListNode reverseBetween(ListNode head, int m, int n) {
        // base case
        if (m == 1) {
            return reverseN(head, n);
        }
        // 前进到反转的起点触发 base case
        head.next = reverseBetween(head.next, m - 1, n - 1);
        return head;
    }

    // 反转以 head 为起点的 n 个节点，返回新的头结点
    ListNode reverseN(ListNode head, int n) {
        if (n == 1) { 
            // 记录第 n + 1 个节点
            successor = head.next;
            return head;
        }
        // 以 head.next 为起点，需要反转前 n - 1 个节点
        ListNode last = reverseN(head.next, n - 1);

        head.next.next = head;
        // 让反转之后的 head 节点和后面的节点连起来
        head.next = successor;
        return last;
    }   
}

LC25（链表每k个节点进行一次反转）

. - 力扣（LeetCode）

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if (head == null) return null;
        // 区间 [a, b) 包含 k 个待反转元素
        ListNode a, b;
        a = b = head;
        for (int i = 0; i < k; i++) {
            // 不足 k 个，不需要反转，base case
            if (b == null) return head;
            b = b.next;
        }
        // 反转前 k 个元素
        ListNode newHead = reverse(a, b);
        // 递归反转后续链表并连接起来
        a.next = reverseKGroup(b, k);

        return newHead;
    }

    /* 反转区间 [a, b) 的元素，注意是左闭右开 */
    ListNode reverse(ListNode a, ListNode b) {

        ListNode pre, cur, nxt;
        pre = null;
        cur = a;
        nxt = a;
        // while 终止的条件改一下就行了
        while (cur != b) {
            nxt = cur.next;
            cur.next = pre;
            pre = cur;
            cur = nxt;
        }
        // 返回反转后的头结点
        return pre;
    }
}