单链表反转总结

1. 反转整个链表

public class SingleList {
        // 1.迭代反转单链表
        public static ListNode reverse(ListNode head){
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode tempNode = curr.next;
            curr.next = prev;
            prev = curr;
            curr = tempNode;
        }
        return prev;
    }
    
    // 2.递归反转单链表
    ListNode reverse(ListNode head) {
    if (head.next == null) return head;
    ListNode last = reverse(head.next);
    head.next.next = head;
    head.next = null;
    return last;
}
}

 2. 反转链表的前N个节点

// 将单链表的前 n 个节点反转（n <= 链表长度）
// 记录后续不需要反转节点的起始节点
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;
} 

3. 反转链表的一部分

    // 反转链表的部分节点:给一个索引区间 [m,n]（索引从1开始），仅仅反转区间中的链表元素
    public static ListNode reverseBetween(ListNode head, int m, int n) {
        if (m == 1) {
            // 此时就退化为反转链表的前N个节点,N=(n - m)
            return reverseN(head, n);
        }
        head.next = reverseBetween(head.next, m - 1, n - 1);
        return head;
    }

对于反转链表，递归解法需要不停开辟栈空间，空间复杂度为O(N);

迭代解法空间复杂度是 O(1)。