【算法】92. Reverse Linked List II

思路：

把指针移动到想要开始反转的节点，然后反转之后的K的节点。

代码：

递归反转整个链表：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (head == nullptr || head->next == nullptr) {
            return head;
        }

        ListNode* last = reverseList(head->next);
        head->next->next = head;
        head->next = nullptr;
        
        return last;
    }
};

这是链表的后序遍历。 

注意：要让本指针的next设为nullptr (head->next = nullptr)，否则在第一个节点将会造成循环。返回last因为需要反转之后的链表的头节点。

递归反转链表的头N个值：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
ListNode* reverseN(ListNode* head, int n) {
    if (n == 1) {
        successor = head->next;
        return head;
    }

    ListNode* last = reverseN(head->next, n-1);
    head->next->next = head;
    head->next = successor;

    return last;
}

反转链表的一部分：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
private:
    ListNode* successor = nullptr;

public:
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        if (head == nullptr || head->next == nullptr) {
            return head;
        }

        ListNode* dummy = new ListNode(-1);
        dummy->next = head;

        ListNode* p1 = dummy;
        for (int i = 0; i < left - 1; i++) {
            p1 = p1->next;
        }

        ListNode* last  = reverseN(p1->next, right-left+1);
        p1->next = last;
        return dummy->next;
    }

    ListNode* reverseN(ListNode* head, int n) {
        if (n == 1) {
            successor = head->next;
            return head;
        }

        ListNode* last = reverseN(head->next, n-1);
        head->next->next = head;
        head->next = successor;

        return last;
        
    }
};

需要dummy头节点是因为：reverseN(p1->next, right-left+1); 在这里p1是要翻转的前一个node，要用dummy防止从第一个node开始反转，此时前一个node是空的的情况。

记录：

一刷：5.27

没有用dummy节点

二刷：6.9

漏写了：

if (head == nullptr || head->next == nullptr) {
    return head;
}

right-left+1写成了left-right+1

链接：

https://leetcode.com/problems/reverse-linked-list-ii/

https://leetcode.com/problems/reverse-linked-list/

递归魔法：反转单链表 :: labuladong的算法小抄