Reverse Linked List II

最新推荐文章于 2024-01-12 14:53:46 发布

原创最新推荐文章于 2024-01-12 14:53:46 发布 · 501 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Reverse #linked #list

Leetcode题录专栏收录该内容

34 篇文章

订阅专栏

本文介绍了一种在给定范围内反转单链表的有效方法，并提供了两种不同的实现方式：一种较为详细的逐步实现，另一种则是更为简洁的版本。这两种方法都能够在一次遍历中完成任务，且不需要额外的空间。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Reverse a linked list from position m to n. Do it in-place and in one-pass.

For example:
Given 1->2->3->4->5->NULL, m = 2 and n = 4,

return 1->4->3->2->5->NULL.

Note:
Given m, n satisfy the following condition:
1 ≤ m ≤ n ≤ length of list.

/**
 * 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) {
        ListNode * dummy = new ListNode(0);
        dummy->next = head;
        ListNode * pre = dummy;
        int i = m;
        while(--i > 0 && pre != NULL){
            pre = pre->next;
        }
        ListNode * mpre = pre;
        if(!mpre)
            return head;
        ListNode * pM = mpre->next;
        i = n - m;
        if(i > 0){
            pre = pM;
            if(!pre)
                return head;
            ListNode * pTemp = pre->next;
            ListNode * pNext = NULL;
            while(i-- > 0 && pTemp){
                pNext = pTemp->next;
                pTemp->next = pre;
                pre = pTemp;
                pTemp = pNext;
            }
            mpre->next = pre;
            pM->next = pTemp;
        }
        return dummy->next;
    }
};

自己第一次写的时候把没有保存m和n，直接先对m作–m操作，再对n作n-=m的操作，结果导致自己被坑了一个晚上，以后写代码一定要注意尽量对参数进行保存。

/**
 * 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) {
        ListNode dummy(0);
        if(!head)
            return head;
        dummy.next = head;
        ListNode * pre = &dummy;
        for(int i = 1; i < m; i++){
            pre = pre->next;
        }
        ListNode * mpre = pre;
        ListNode * pm = mpre->next;
        pre = pm;
        ListNode * cur = pm->next;
        for(int i = m; i < n; i++){
            ListNode * temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        mpre->next = pre;
        pm->next = cur;
        return dummy.next;
    }
};

经过提醒出一个简洁版本。

/**
 * 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) {
        ListNode dummy(0);
        if(!head)
            return head;
        dummy.next = head;
        ListNode * pre = &dummy;
        for(int i = 1; i < m; i++){
            pre = pre->next;
        }
        ListNode * pm = pre->next;
        for(int i = m; i < n; i++){
            ListNode * pn = pm->next;
            pm->next = pn->next;
            pn->next = pre->next;//注意不能使用pn->next=pm，因为即将修改pre->next
            pre->next = pn;
        }
        return dummy.next;
    }
};