【反转链表合集】

写在前面：本博客仅作记录学习之用，部分图片来自网络，如需使用请注明出处，同时如有侵犯您的权益，请联系删除！

---

---

反转单链表

---

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例1	示例2

---

解决思路

• 迭代：在遍历链表时，记录当前节点的前一个节点和下一个节点，改变节点的指向即可。

---

代码

//时间复杂度：O(n)，遍历链表一次。
//空间复杂度：O(1)。
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        // 无元素或最一个元素为空时直接返回
        if(head==nullptr || head->next==nullptr) return head;

        else{
            ListNode* cur = head;
            ListNode* pre = nullptr;
            while(cur)
            { 
                // 保存下一个元素
                ListNode* next = cur->next;
                // 下一个元素为前一个元素，反向
                cur->next = pre;
                // 更新上一个元素为当前元素
                pre = cur;
                // 更新当前元素为下一个元素
                cur = next;
            }
            return pre;
        }
    }
};

---

反转链表中K个元素

题目描述

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

解决思路

• 取出反转：在遍历链表时，记录左右节点，利用上述的反转，翻转后把链表接回。
• 头插法：在遍历链表时，依次把左右节点中间的节点置于left，达到反转的目的。

---

代码

取出反转

• 时间复杂度：O(n),最坏情况遍历整个链表
• 空间复杂度：O(1),仅使用几个辅助节点

class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        if(pHead==nullptr || pHead->next==nullptr) return pHead;

        ListNode* pre = nullptr;
        ListNode* cur = pHead;
        while (cur) {
            ListNode* next = cur->next;
            cur->next = pre; 
            pre = cur;
            cur = next;
        }
        return pre;
    }
    
    //时间复杂度：O(n),最坏情况遍历整个链表
    //空间复杂度：O(1),仅使用几个辅助节点
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if(m==n) return head;
        ListNode *dummyNode = new ListNode(-1);
        dummyNode->next = head;

        ListNode* start = nullptr;
        ListNode* end = nullptr;

        ListNode* cur = dummyNode;

        //寻找子链表头的前一个节点
        for(int i=0; i<m-1; i++){
            cur = cur->next;
        }
        //start记录子链表头的前一个节点
        start = cur;

        //寻找子链表尾的节点
        for(int i=0; i<n-m+1; i++){
            start = start->next;
        }
        // end 记录子链表尾的节点
        end = start;

        //截取链表
        ListNode* leftt = cur->next;
        ListNode* rightt = start->next;

        //切断链表
        cur->next = nullptr;
        start->next = nullptr;

        //反转子链表
        ListNode* ret = ReverseList(leftt);

        //链接回去：左节点
        cur->next = ret;
        
        //得到反转子链表的尾节点
        for(int i=0; i<n-m; i++){
            ret = ret->next;
        }

        //链接回去：右节点
        ret->next = rightt;

        return dummyNode->next;
    }
};

头插法

• 时间复杂度：O(N)， 最多只遍历了链表一次。
• 空间复杂度：O(1)。只使用到常数个变量。

class Solution {
public:
    ListNode *reverseBetween(ListNode *head, int left, int right ) {
        // 设置 dummyNode 是这一类问题的一般做法
        ListNode* dummyNode = new ListNode(-1);
        dummyNode->next = head;
        
        ListNode* pre = dummyNode;
        // 注意循环次数left，(1--left)/(0--left-1)
        for(int i = 1; i < left; i++){
            pre = pre->next;
        }

        // pre->cur->next
        ListNode* cur = pre->next;
        ListNode* next;

        // 注意循环次数right-left
        for(int i = 0; i < right-left; i++){
            // 记录下一个节点
            next = cur->next;

            // 从后往前,next->next=========>前驱=========>前驱==========>前驱
            //          next->next=========>cur=========>next===========>pre
            cur->next = next->next;
            next->next = pre->next;
            pre->next = next;
        }

        return dummyNode->next;
    }
};

---

K个元素一组反转

题目描述

链表的头节点 head ，每 k 个节点一组进行翻转，返回修改后的链表。k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，最后剩余的节点保持原有顺序。

解决思路

• 头插法：在遍历链表时，依次把K节点以头插法达到反转。

代码

• 时间复杂度：O(N)， 遍历了链表2次。
• 空间复杂度：O(1)，只使用到常数个变量。

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(k == 1) return head;
        ListNode* dunmyNode = new ListNode(-1); //避免边界问题
        dunmyNode->next = head;
        ListNode* pre = dunmyNode;
        ListNode* cur = pre->next;
        // 记录节点数
        int i = 0;
        while(head){
            i++;
            head = head->next;
        }
        ListNode* next; 
        while(i/k){
            // 首插法，反转K个元素
            for(int j = 0; j < k-1; j++){
                next = cur->next;
                cur->next = next->next;
                next->next = pre->next;
                pre->next = next;
            }
            // 为下k个数据设置pre, cur
            pre = cur;
            cur = cur->next;
            // 记录剩余节点数，以便跳出循环
            i -= k;
        }
        return dunmyNode->next;
    }
};

---

致谢

欲尽善本文，因所视短浅，怎奈所书皆是瞽言蒭议。行文至此，诚向予助与余者致以谢意。