力扣92. 反转链表 II（）

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

示例 1：

输入：head = [1,2,3,4,5], left = 2, right = 4
输出：[1,4,3,2,5]

示例 2：

输入：head = [5], left = 1, right = 1
输出：[5]

提示：

• 链表中节点数目为 n
• 1 <= n <= 500
• -500 <= Node.val <= 500
• 1 <= left <= right <= 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) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        if (head == nullptr || left == right) {
            return head;
        }
        
        ListNode* dummy = new ListNode(0); // 创建一个虚拟节点
        dummy->next = head;
        ListNode* prev = dummy;
        
        // 找到左侧节点的前一个节点
        for (int i = 1; i < left; ++i) {
            prev = prev->next;
        }
        
        ListNode* cur = prev->next; // 左侧节点
        ListNode* next = nullptr;
        
        // 反转从左侧到右侧的节点
        for (int i = left; i < right; ++i) {
            next = cur->next;
            cur->next = next->next;
            next->next = prev->next;
            prev->next = next;
        }
        
        return dummy->next;
    }
};

 

这段代码实现的是反转链表中指定区间的节点。首先判断如果链表为空或者left和right相等，那么不需要反转直接返回原链表头节点。然后创建一个虚拟节点dummy，并让dummy的next指针指向head，这样就可以避免需要特殊处理头节点的情况。接下来，使用prev指针找到左侧节点的前一个节点，即第left-1个节点。然后定义cur指针指向左侧节点，同时定义next指针用来保存下一个节点的指针。然后使用一个循环，循环条件是i从left取到right-1，每次循环，将cur的next指针指向next->next，即将next节点从链表中断开并跳过。然后将next的next指针指向prev的next，即将next节点放到prev节点的后面。最后，将prev的next指针指向next，完成反转。最后返回dummy的next指针，即新的链表头节点。

解法二：先将要翻转的部分拆出来翻转再接回去 

/**
 * 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 {
    void reverseLinkdeList(ListNode* head){
        if(!head||!head->next)
        return ;
        reverseLinkdeList(head->next);
        head->next->next=head;
        head->next=nullptr;
    }
public:
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        ListNode* dummynode=new ListNode(-1);
        dummynode->next=head;

        ListNode* pre=dummynode;
        for(int i=1;i<left;i++){
            pre=pre->next;
        }

        ListNode* rightnode=pre;
        for(int i=left;i<=right;i++){
            rightnode=rightnode->next;
        }

        ListNode* leftnode=pre->next;
        ListNode* curr=rightnode->next;

        pre->next=nullptr;
        rightnode->next=nullptr;

        reverseLinkdeList(leftnode);

        pre->next=rightnode;
        leftnode->next=curr;
        return dummynode->next;
    }
};

 

这段代码实现的是反转链表中指定区间的节点。首先定义了一个辅助函数reverseLinkedList，用于反转一个链表。该函数使用递归的方式进行反转，先判断如果链表为空或只有一个节点，则不需要反转，直接返回。然后调用递归函数，将当前节点的next指针指向当前节点的前一个节点，然后将当前节点的next指针设为nullptr。然后在主函数中，创建一个虚拟节点dummy，并将其next指针指向head。然后使用两个指针pre和rightnode来找到需要反转的区间。从头节点开始，pre指针先移动到left的前一个节点，rightnode指针移动到right节点。然后将left节点保存为leftnode，将right节点保存为curr。然后将pre节点的next设为nullptr，将right节点的next设为nullptr，这样可以将需要反转的区间与链表断开。接下来调用reverseLinkedList函数来反转leftnode节点，将其变成以rightnode为头节点的链表。然后将pre节点的next指向rightnode，将leftnode的next指向curr节点，重新连接起来。最后返回dummy的next指针，即新的链表头节点。