【算法-链表】链表操作技巧:常见算法

最新推荐文章于 2025-05-10 18:09:08 发布
最新推荐文章于 2025-05-10 18:09:08 发布
阅读量1.2k 收藏 61
点赞数 79
分类专栏： # 优选算法 算法分析 文章标签： 算法 链表 android c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79177254/article/details/147466137
版权

请添加图片描述

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

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

请添加图片描述

Alt

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

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

文章目录

链表常用技巧和操作总结

a.常用技巧

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

2.引入虚拟"头"节点

​ a.便于处理边界情况

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

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

在这里插入图片描述

b.链表中的常用操作

  1. 创建一个新节点 new

  2. 尾插操作

  3. 头插操作(逆序链表)

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 个升序链表

image-20250302163236509

【算法思路】

解法一：优先级队列

在这里插入图片描述

面对 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);如果是空节点，没有必要插入堆里面进行排序，会大幅度提高空间复杂度。

image-20250302164552840

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

25.K 个一组翻转链表

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

在这里插入图片描述

【算法思路】

解法:模拟

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

  1. 【第一步】:先求出需要逆序多少组:n
  2. 【第二步】：重复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;
    }
};

在这里插入图片描述
快和小二一起踏上精彩的算法之旅！关注我，我们将一起破解算法奥秘，探索更多实用且有趣的知识，开启属于你的编程冒险！

算法-链表：链表的常见六个操作
weixin_60952096的博客
01-24 670
算法-链表：链表的常见六个操作 设计一个链表，实现六个接口： 1、获取链表的第index个节点的数值。 2、在链表的最前面插入一个节点。 3、在链表的最后面插入一个节点。 4、在链表的第index个节点前面插入一个节点。 5、删除链表的第index个元素。 6、打印当前链表。 注意：index从0开始，第0个节点就是头节点。 在对链表进行插入和删除操作时，重点是找到前一个节点。 #include <iostream> using namespace std; class MyFirstList
算法-链表：探索相交链表的奥秘
master_chenchen的博客
07-06 627
相交链表是指两个或多个链表共享一部分节点的现象。在C++中，链表由一系列节点构成，每个节点包含数据和指向下一个节点的指针。当两个链表的某部分节点重叠时，便形成了相交链表。这一特性在数据结构的分析和设计中显得尤为重要，尤其是在处理复杂的数据关系和优化数据查询效率方面。
算法-链表：反转链表的艺术
master_chenchen的博客
07-06 785
反转链表，顾名思义，就是将链表中的节点按照相反的顺序重新链接，使得链表的头部变成尾部，尾部变成头部。这一操作在数据结构的调整、算法优化等领域有着广泛的应用，尤其在需要改变数据访问顺序或进行数据预处理的场景中，更是不可或缺。
算法-链表：两数相加的艺术
master_chenchen的博客
07-07 885
链表两数相加，指的是给定两个非空链表，每个节点代表一个数字的一位，数字的高位在链表的前端，低位在后端，求这两个数相加的结果并以同样的形式返回。这一问题不仅考验了我们对链表操作的熟练程度，也检验了我们处理进位运算的能力。
【数据结构与算法-链表经典例题汇总】
是小武呀
03-01 2074
【数据结构与算法-链表经典例题汇总】典例1、链表逆序-a（easy）典例1、链表逆序-b（medium）典例2、求两个链表的交点-（easy）典例3、链表求环 - （medium）典例4、链表划分- (medium)典例5、复杂链表的深度拷贝 - (hard)典例6、排序链表的合并a-两个（easy）典例6、排序链表的合并b-多个（hard） 典例1、链表逆序-a（easy） 题目描述： 思路：依次遍历链表的节点，每遍历一个节点就逆置一个节点 。 LeetCode提交OJ测试链接: OJ
C++算法题 - 链表
一个愚蠢的研究牲
04-25 1192
力扣算法题：141，2，21，138，92，25，19，82，61，86，146
Java 算法篇-链表的经典算法：有序链表去重、合并多个有序链表
小扳手
11-18 3676
有序链表去重的方法、合并多个升序链表的方法： 在此之前，需要分为两个方向：第一个方向为：需要保留重复值的节点 使用递归来实现有序链表的去重、使用双指针来实现有序链表的去重。第二个方向为：不需要保留重复值的节点。使用递归来实现有序链表的去重、使用三指针来实现有序链表的去重。一、合并两个升序链表使用迭代法实现合并链表、使用递归实现合并链表二、合并多个升序链表合并多个升序链表就是一个个合并两个升序链表的情况，用递归来实现。
直击高频编程考点：链表知识及经典算法题总结
热门推荐
张彦峰的博客
10-24 4万+
了解链表结构，并在单链表或双链表中实现遍历、插入和删除以及分析在单链表或双链表中的各种操作的复杂度，同时附上相关面试考点的基本分类试题库（反转链表、链表中环的检测、链表中环的入口点、删除链表中倒数第K个节点、两个链表的第一个公共节点、链表的中间节点、合并两个有序链表、删除链表中的重复元素、排序链表、K 个一组翻转链表、旋转链表、分隔链表、奇偶链表、合并k个排序链表、链表相加、回文链表判定、回文链表重排、交换相邻节点、删除指定元素、反转链表指定部分、存在回文链表、链表最长递增子序列）
链表常用技巧和操作总结
Y_1215的博客
11-08 1077
链表作为一种基础的数据结构，在算法中有着广泛的应用。掌握链表的常用操作和技巧，不仅能够帮助我们解决具体问题，还能在实际的编程中提升效率和代码质量。头插法：用于栈的实现和一些数据流反转操作。尾插法：适用于队列的实现和批量数据导入的场景。快慢指针找中间节点：在分割链表、回文链表检测、查找链表中点等问题中常用。逆序链表：常用于栈的反转和数据流反转等应用。合并有序链表：广泛应用于归并排序、数据流合并等问题中。判断链表是否有环：常用于循环链表检测，避免程序出现无限循环等问题。
链表 - 数据结构与算法 - 链表算法
11-01
链表是一种常见的基础数据结构，它由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。链表的特殊之处在于它不要求内存是连续的，这与数组等其他数据结构形成对比。在链表中，通过指针将各个节点连接...
Java算法篇-链表去重与合并.pptx.pptx
12-18
在Java算法领域，链表是一种重要...总之，链表去重与合并是数据结构与算法中常见的问题，理解和掌握这些操作对于优化数据处理流程至关重要。在Java中，通过熟练运用链表的特性和算法设计原则，可以实现高效的链表操作。
算法大全-面试题-链表-栈-二叉树-数据结构.docx
09-01
【链表】 链表是一种线性数据结构，其中元素以节点的...这些操作展示了链表的灵活性和多样性，理解和熟练掌握这些操作对于解决实际问题和面试准备至关重要。在实际编程中，了解和应用这些算法能够提高解决问题的效率。
leetcode-Linked-List-2:链表-2
06-29
链表的反转是一个常见的面试题，它可以测试你对指针操作的掌握程度。反转链表通常有几种方法，包括迭代和递归。迭代方法通常使用三个指针，前一个节点、当前节点和下一个节点；递归方法则是将链表的剩余部分递归反转...
2025.05.07-淘天研发岗-第一题
春秋招笔试突围
05-09 75
她发现，当且仅当一组结晶石的能量乘积是完全平方数时，这组结晶石能够产生共振。完全平方数是指可以表示为某个整数的平方的数，如1、4、9等。要使乘积是完全平方数，我们需要所有质因子的指数和都是偶数。总体来说，这道题的难点在于将"乘积是完全平方数"转化为"所有质因子的指数和都是偶数"，并利用位运算高效地判断和统计符合条件的组合。我们知道，一个数是完全平方数当且仅当它的所有质因子的指数都是偶数。比如说，4 = 2² 是完全平方数，而6 = 2¹ × 3¹ 不是完全平方数，因为2和3的指数都是1（奇数）。
YOLO目标检测算法评估标准
jdjhcn的博客
05-10 770
不同类型的模型，评估指标各有侧重。分类模型中，准确率反映预测正确的整体比例；精确率关注预测正例中实际正例的占比；召回率衡量实际正例被正确预测的程度；F1 值综合精确率与召回率，适合样本不均衡场景。回归模型里，均方误差计算预测值与真实值误差平方的均值，能体现平均差异；平均绝对误差以误差绝对值平均，对异常值敏感度低；聚类模型中，轮廓系数综合凝聚度和分离度，值近 1 代表聚类佳。那么我们今天学习的YOLO目标检测模型使用什么指标评估模型的效果。
【算法】：滑动窗口
jerryhe_com的博客
05-09 961
滑动窗口的时间复杂度实现了从原来的n * n 变成了 o(n) 因为left,right指针都只遍历了数组一次。
算法训练营第十三天｜226.翻转二叉树、101. 对称二叉树、 104.二叉树的最大深度、111.二叉树的最小深度
最新发布
suwnbs的博客
05-10 315
*carl的讲解：**因为最小深度的判别要比最大深度复杂。直接将max改成min是不行的，因为会把非叶子节点的值当作最小值返回。因为这个非叶子节点可能离根节点不愿，左边没节点但是右边有节点，这样他就可能得出的depth很小，但是他都不是叶子节点。**carl的讲解：**不再显示传递depth参数，因为递归本身隐式计算深度。可以用层序遍历，记录层数。就是简单的改前面的最大深度为最小深度。但是踩坑了，不是这么简单。发现超时的原因了，因为 16、17、18行的代码将。写了出来，在37/39个示例报超时。
基于OpenCV的人脸识别：FisherFaceRecognizer算法
zdx2585503940的博客
05-10 770
这个系统使用OpenCV的算法，通过训练少量样本图片，实现对输入图像的分类识别。加载训练图像并预处理训练FisherFace识别器对测试图像进行预测在图像上显示中文识别结果这个简单的系统展示了如何使用OpenCV实现基本的人脸识别功能。虽然只使用了少量训练样本，但已经能够完成基本的分类任务。增加更多训练样本提高准确性使用更先进的算法如LBPH或深度学习模型添加人脸检测步骤实现全自动识别构建更完善的用户界面完整代码已在上文展示，读者可以根据需要调整参数或扩展功能。
算法2-8~2-11：链表的基本操作
06-28
### 回答1： 算法2-8：链表的创建 1. 定义一个链表结构体 2. 初始化头结点 3. 循环读入数据，创建新的结点并插入链表尾部 算法2-9：链表的遍历 1. 从头结点开始，依次遍历链表中的每个结点 2. 对每个结点进行相应的操作 算法2-10：链表的插入 1. 找到要插入的位置 2. 创建新的结点 3. 将新结点插入到链表中 算法2-11：链表的删除 1. 找到要删除的结点 2. 将该结点的前驱结点指向该结点的后继结点 3. 释放该结点的内存空间 ### 回答2： 链表是一种非常基础的数据结构，在计算机科学中具有很重要的作用。链表是由若干个节点组成的，每个节点都包含数据和一个指向下一个节点的指针。链表的优点是可以动态地增加或删除节点，而不需要移动其他节点。链表的基本操作包括创建链表、插入节点、删除节点和遍历链表，下面分别介绍。 首先是创建链表的操作。创建链表需要一个头节点，头节点不包含数据，只是用来表示链表的开始。可以通过如下代码来创建一个空链表： ``` typedef struct Node{ int data; struct Node *next; } Node; Node *create_list() { Node *head = (Node*)malloc(sizeof(Node)); head->next = NULL; return head; } ``` 接下来是插入节点操作。插入节点需要先找到要插入的位置，然后修改指针指向。如果要在链表的头部插入节点，可以直接将头指针修改为新节点；如果要在链表的中间或尾部插入节点，则需要遍历链表，找到要插入位置的前一个节点，然后修改前一个节点的next指针即可。如下代码就是在链表尾部插入一个值为value的节点： ``` void insert_node_tail(Node *head, int value){ Node *p = head; while(p->next != NULL){ p = p->next; } Node *new_node = (Node*)malloc(sizeof(Node)); new_node->data = value; new_node->next = NULL; p->next = new_node; } ``` 删除节点操作与插入节点操作类似，也需要找到要删除的位置，然后修改指针指向。如果要删除链表头节点，只需将头指针修改为下一个节点即可；如果要删除中间或尾部的节点，则需要遍历链表，找到要删除位置的前一个节点，然后将其next指针指向下一个节点的next指针即可。如下代码就是删除链表中值为value的第一个节点： ``` void delete_node(Node *head, int value){ Node *p = head; while(p->next != NULL && p->next->data != value){ p = p->next; } if(p->next != NULL){ Node *tmp = p->next; p->next = p->next->next; free(tmp); }else{ printf("值为%d的节点不存在\n", value); } } ``` 最后是遍历链表操作。遍历链表可以使用while循环和指针变量遍历整个链表，将节点的值打印出来即可。如下代码就是遍历链表并打印出每个节点的值： ``` void traverse_list(Node *head){ Node *p = head->next; while(p != NULL){ printf("%d ",p->data); p = p->next; } } ``` 以上就是链表的基本操作，其中涉及到了指针操作、动态内存分配和链表节点的定义等知识点。掌握这些操作能够在实际编程中应用链表这种数据结构，提高算法的效率和代码的可维护性。 ### 回答3： 1.算法2-8：插入节点。 这个算法的目的是向链表中插入新的节点，将新节点放在指定节点的后面。 首先，我们需要通过一个循环找到需要插入的位置，即需要插入节点的前一个节点。 然后，我们将新节点连接到链表中，并将指定节点的下一个节点连接到新节点上。 最后，我们需要检查该插入的位置是否为空，如果为空，则新节点是链表的最后一个节点。 2.算法2-9：删除节点。 该算法的目的是从链表中删除一个指定的节点。 首先，我们需要找到该节点的前一个节点，以便将该节点从链表中删除。 然后，我们需要将该节点从链表中断开，并将该节点的下一个节点连接到前一个节点。 最后，我们需要确保链表中不再有对该节点的引用。 3.算法2-10：查找值。 在链表中查找一个特定的值是很常见的操作。该算法的目的就是查找给定值在链表中的位置。 首先，我们需要从链表的头部开始查找，直到我们找到该值或者到达链表的末尾。 找到值后，我们需要返回该节点在链表中的位置。 如果在整个链表中都没有找到该值，我们需要返回一个错误。 4.算法2-11：遍历链表。 链表的遍历是指按顺序遍历链表中的每个节点。 该算法的目的就是打印链表中的每个节点的值。 首先，我们需要从链表的头部开始，重复访问链表中的每个节点。 我们可以使用一个循环来遍历整个链表，每次访问一个节点，打印该节点的值，然后移动到下一个节点，直到到达链表的末尾。 如果链表为空，我们将不会打印任何值。
评论 49
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

是店小二呀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值