[LeetCode 中等 链表]92. 反转链表 II

题目描述

反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。

说明:
1 ≤ m ≤ n ≤ 链表长度。

示例:

输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL
通过次数96,546提交次数185,632

按思路直接写

/**
 * 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 reverseBetween(ListNode head, int m, int n) {

        if(n==1) return head;

        // firstEnd走到第一段的结尾
        // SecHead走到第二段的开头
        ListNode firstTail = null;
        ListNode SecHead = head;
        while(m>1){
            firstTail = SecHead;
            SecHead = SecHead.next;
            n--;
            m--;
        }

        //SecEnd 走到第二段的结尾
        ListNode prev = null;
        ListNode SecEnd = SecHead;
        ListNode ThirdHead =SecEnd.next;
        while(n>1){
            prev = SecEnd;
            SecEnd = ThirdHead;
            ThirdHead=SecEnd.next;
            SecEnd.next = prev;
            n--;
        }

        //首尾相接 
   
        // System.out.println(SecEnd.val); 
        if(firstTail != null)  firstTail.next = SecEnd;
        else head =SecEnd ;
        SecHead.next = ThirdHead; 
        return head;
    }
}

递归

首先理解普通的反转链表的递归

其次理解反转链表前n个节点的递归

最后理解反转m-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;
    }    


    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;
    }
}