【LeetCode-链表】反转链表 II

题目描述

反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。
说明:
1 ≤ m ≤ n ≤ 链表长度。
示例：

输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL

题目链接：https://leetcode-cn.com/problems/reverse-linked-list-ii/
做这题之前可以先做一下：反转链表，题解.

思路

和反转链表类似，将“反转链表”中的循环条件更改为在[m,n]范围内循环即可。由于m可能为1，也就是从第一个节点开始反转，所以要再创建一个新的头结点指向原来的头结点。代码如下：

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

        ListNode* newHead = new ListNode(0); //m可能等于1，所以创建一个新头结点
        newHead->next = head;
        ListNode* node = newHead;
        for(int i=1; i<m; i++){ //注意循环条件
            node = node->next;
        }
        ListNode* curNode = node->next; //curNode是原链表中的第m个节点,node是原链表中第m-1个节点
        ListNode* preNode = nullptr;
        ListNode* nextNode = nullptr;
        for(int i=m; i<=n; i++){    //注意循环条件
            nextNode = curNode->next;
            curNode->next = preNode;
            preNode = curNode;
            curNode = nextNode;
        }
        ListNode* temp = node->next;    //temp是反转后的链表尾结点
        node->next = preNode;   //将原链表中第m-1的节点的下一个节点设为反转后的链表头preNode
        temp->next = curNode;   //将反转后的链表尾指向原链表的第n+1个节点curNode
        return newHead->next;
    }
};

也可以把 [m, n] 范围内的链表拿出来反转后再加到原来的位置。代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if(head==NULL) return 0;

        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* cur = dummy;
        for(int i=0; i<m-1; i++){  // 注意范围
            cur = cur->next;
        }
        ListNode* preTail = cur;  // preTail 是第 m-1 个节点
        for(int i=0; i<n-m+1; i++){  // 注意范围
            cur = cur->next;
        }
        ListNode* nextHead = cur->next; // nextHead 是第 n+1 个节点
        cur->next = NULL;
        ListNode* curHead = preTail->next; // curHead 是反转前的链表头，反转后的链表尾
        preTail->next = reverse(curHead);
        curHead->next = nextHead;
        return dummy->next;
    }

    ListNode* reverse(ListNode* head){ // 链表翻转
        if(head==NULL) return head;

        ListNode* pre = NULL;
        ListNode* cur = head;
        while(cur!=NULL){
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
};

• 时间复杂度：O(n)
• 空间复杂度：O(1)

相似题目

1、反转链表：https://leetcode-cn.com/problems/reverse-linked-list/，题解
2、K个一组反转链表：https://leetcode-cn.com/problems/reverse-nodes-in-k-group/，题解