【优选算法 | 链表】链表操作技巧:常见算法

请添加图片描述

算法	相关知识点	可以通过点击	以下链接进行学习	一起加油！
双指针	滑动窗口	二分查找	前缀和	位运算
模拟

链表是一种灵活的数据结构，广泛用于需要频繁插入和删除的场景。掌握链表的常见操作技巧，如插入、删除、翻转和合并等，能帮助开发者更高效地解决实际问题。接下来，我们将探讨一些常见的链表算法及其应用。

请添加图片描述

Alt

🌈个人主页：是店小二呀
🌈C/C++专栏：C语言\ C++
🌈初/高阶数据结构专栏：初阶数据结构\ 高阶数据结构
🌈Linux专栏： Linux
🌈算法专栏：算法
🌈Mysql专栏:Mysql

🌈你可知:无人扶我青云志我自踏雪至山巅请添加图片描述

文章目录

链表常用技巧和操作总结
- a.常用技巧
- b.链表中的常用操作
- 2.两数相加
- 24.两两交换链表中的节点
- 143.重排链表
- 23.合并 K 个升序链表
- 25.K 个一组翻转链表

链表常用技巧和操作总结

a.常用技巧

1.画图(直观 + 形象)，便于我们理解

2.引入虚拟"头"节点

a.便于处理边界情况

b.方便我们对于链表操作，处理方式跟后续节点方式统一

3.不要吝啬空间，大胆去定义变量，简洁节点链接表达方式

在这里插入图片描述

b.链表中的常用操作

创建一个新节点 new

尾插操作

头插操作(逆序链表)

2.两数相加

【题目】：2. 两数相加

在这里插入图片描述

【算法思路】

逆序’关键字表明链表已经完成了逆序操作。在链表相加的题目中，通常也需要先将链表逆序，因为加法操作是从最低位开始的，相当于模拟竖式加法。因此，为了正确执行加法操作，链表需要先进行逆序处理。

在这里插入图片描述

解法：模拟两数相加的过程

在这里插入图片描述

如果不创建虚拟头节点，就需要将两数相加的结果作为一个头节点，这样会导致计算顺序不够简洁，需要先计算结果，再将后续的节点相加，增加了一些额外的步骤。相比之下，先创建虚拟头节点可以直接开始加法操作，模拟加法时进位 t = 0，这样整个过程更加直观且高效。使用头插法可以简化这一过程。

【代码实现】

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2)
    {
        ListNode * cur1 = l1, * cur2 = l2;
        ListNode * newhead = new ListNode(0);
        ListNode * prev = newhead;
        int t = 0;
        while(cur1 || cur2 || t)
        {
            if(cur1)
            {
                t += cur1 -> val;
                cur1 = cur1->next;
            }
            if(cur2)
            {
                t += cur2 -> val;
                cur2 = cur2 -> next;
            }
            
            prev -> next = new ListNode(t % 10);
            prev = prev -> next;
            t /= 10;
        }
        
        prev = newhead -> next;
        delete newhead;

        return prev;
    }
};

【细节问题】：while(cur1 || cur2 || t)，出现下面这种情况，进位是需要被考虑的。

在这里插入图片描述

24.两两交换链表中的节点

【题目】：24. 两两交换链表中的节点
在这里插入图片描述

【算法思路】

解法一：递归

解法二：循环、迭代(模拟)

在这里插入图片描述

题目要求涉及链表间指向转化，可以使用到我们的技巧"不要吝啬空间，大胆去定义变量，简洁节点链接表达方式"，这里同样需要创建虚拟"头"节点，便于我们进行运算操作，通过绘图，我们可以很直观知道模拟过程

【细节问题】

在这里插入图片描述

循环结束条件就是cur == nullptr && next == nullptr。

【代码实现】

class Solution {
public:
    ListNode* swapPairs(ListNode* head) 
    {
        if(head == nullptr || head -> next == nullptr) return head;
        ListNode * newHead = new ListNode(0);
        newHead ->next = head;

       ListNode * prev = newHead, * cur = prev -> next, * next = cur -> next, * nnext = next -> next;
 
        while(cur && next)
        {
            //交换操作
            prev -> next = next;
            next -> next = cur;
            cur -> next = nnext;


            //指针转化操作
            prev = cur;
            cur = nnext;
            if(cur) next = cur -> next;
            if(next) nnext = next -> next;
        }
        
        cur = newHead ->next;
        delete newHead;

        return cur;
    }
};

143.重排链表

【题目】：143. 重排链表

在这里插入图片描述

【算法思路】

解法:模拟

在这里插入图片描述

通过绘图分析，我们可以将问题分为三个问题。

在这里插入图片描述

【1.找到链表的中间节点】

在这里插入图片描述

slow慢指针走一步，fast快指针走两步，判断结束条件为fast && fast->next 。

if(head == nullptr || head -> next == nullptr || head -> next -> next == nullptr)  return;
        //1.快慢指针找到中间节点
        ListNode * slow = head;
        ListNode * fast = head;
        while(fast && fast ->next)
        {
            slow = slow -> next;
            fast = fast ->next ->next;
        }

【2.将后续部分逆序】

这里可以使用双指针(三指针)，头插法。

在这里插入图片描述

这里咱们需要解决是，从slow->next位置逆序，还是从slow位置逆序，链表长度奇偶数，是否对位置选取有影响。

这道题目比较特殊，如果是偶数，我们会发现中间部分和最后部分顺序发现没有改变，

【3.合并两个链表】

这里选择slow -> next位置逆序，链表1长度比链表2长度要长，所以外面判断条件为while(cur1)就行。

        //合并两个链表
        ListNode * ret = new ListNode(0);
        ListNode * prev = ret;
        ListNode * cur1 = head, * cur2 = head2 ->next;

        while(cur1)
        {
            prev -> next = cur1;
            cur1 = cur1 -> next;
            prev = prev -> next;

            if(cur2)
            {
                prev ->next = cur2;
                cur2 = cur2 ->next;
                prev = prev -> next;
            }
        }

【代码实现】

class Solution {
public:
    void reorderList(ListNode* head) 
    {
        if(head == nullptr || head -> next == nullptr || head -> next -> next == nullptr)  return;
        //1.快慢指针找到中间节点
        ListNode * slow = head;
        ListNode * fast = head;
        while(fast && fast ->next)
        {
            slow = slow -> next;
            fast = fast ->next ->next;
        }

        //2.获得两个链表
        ListNode * head2 = new ListNode(0);
        ListNode * cur = slow -> next;
        slow->next = nullptr;

        //3.链表逆序
        while(cur)
        {
            ListNode * next = cur ->next;
            cur -> next = head2 ->next;
            head2 -> next = cur;
            cur = next;
        }

        //合并两个链表
        ListNode * ret = new ListNode(0);
        ListNode * prev = ret;
        ListNode * cur1 = head, * cur2 = head2 ->next;

        while(cur1)
        {
            prev -> next = cur1;
            cur1 = cur1 -> next;
            prev = prev -> next;

            if(cur2)
            {
                prev ->next = cur2;
                cur2 = cur2 ->next;
                prev = prev -> next;
            }
        }
    delete head2;
    delete ret;        
    }
};

23.合并 K 个升序链表

【题目】：23. 合并 K 个升序链表

【算法思路】

解法一：优先级队列

在这里插入图片描述

面对 K 个升序链表，每次需要找到最小节点进行插入，如果使用循环遍历，时间复杂度会变得很高。为了快速找到最小节点或最小的 K 个节点，可以借鉴 topK 问题的思路，利用优先级队列（小堆）来高效地找出最小节点，从而降低时间复杂度。

【代码实现】

class Solution {
public:
    
    struct cmp
    {
        bool operator()(const ListNode* l1, const ListNode* l2)
        {
            return l1->val > l2->val;
        }
    };
    ListNode* mergeKLists(vector<ListNode*>& lists) 
    {
        //创建小堆
        priority_queue<ListNode*, vector<ListNode*>,cmp> heap;

        //将每个链表头节点传入
        for(auto l : lists)
           if(l) heap.push(l);

        ListNode * ret = new ListNode(0);
        ListNode * prev = ret;
        while(!heap.empty())
        {
            ListNode * t = heap.top();
            heap.pop();
            prev ->next = t;
            prev = t;
            if(t ->next) heap.push(t->next);
        }

        prev = ret ->next;
        delete ret;
        return prev;
    }
};

【细节问题】:if(l) heap.push(l);如果是空节点，没有必要插入堆里面进行排序，会大幅度提高空间复杂度。

解法二：递归回溯(留到后面来写)

25.K 个一组翻转链表

【题目】：25. K 个一组翻转链表

在这里插入图片描述

【算法思路】

解法:模拟

面对K个什么题目，应该考虑规律性解法。这里根据题目要求，每 k 个节点一组进行翻转即可。

【第一步】:先求出需要逆序多少组:n
【第二步】：重复n次，长度为k的链表的逆序即可

在这里插入图片描述

使用头插法解决此问题时，考虑到需要将尾节点作为新的头节点重新插入，可以通过使用 tmp = prev 来标记。对于 k 个节点，将首节点头插后，它将成为链表的最后一个节点。为了清晰理解，可以通过绘图展示链表的变化过程。

【代码实现】

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) 
    {
        if(head == nullptr && head->next == nullptr) return head;
        //1.需要逆序多少组
        ListNode * cur = head;
        int n = 0;
        while(cur)
        {
            cur = cur-> next;
            n++;
        }

        n /= k;

        ListNode * newHead = new ListNode(0);
        ListNode * prev = newHead;
        ListNode * tmp = cur;
        cur = head;
        
        for(int i = 0; i < n; i++)
        {
            ListNode * tmp = cur;
            for(int j = 0; j < k; j++)
            {
                ListNode * next = cur->next;
                cur->next = prev ->next;
                prev->next = cur;
                cur = next;
            }
            prev = tmp; 
        }

        prev->next = cur;
        cur = newHead->next;
        delete newHead;
        return cur;
    }
};