链表-算法总结

最新推荐文章于 2024-07-15 17:15:24 发布
最新推荐文章于 2024-07-15 17:15:24 发布
阅读量425 收藏 1
点赞数
分类专栏： 算法总结 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60524373/article/details/126765932
版权

目录

移除链表元素

设计链表

翻转链表

 两两交换链表中的节点

删除链表的倒数第N个节点

链表相交

环形链表

对链表中常用的，虚拟头节点，增删改查，翻转，删除倒数节点，环形链表进行了介绍

移除链表元素

用于单链表中删除指定元素，常用的方法包括：1虚拟节点操作，2原节点操作。

方法：

我们先以2原节点操作举例：

思路在于，我们需要做两次判断，第一种为被删除元素为头节点位置，第二种为非头节点位置。

头节点位置处理的思路是：

如果该头节点为目标值，那么我们让头节点的下一个节点为节点，

head = head->nex

之和我们在返回head头节点时，其实返回的是最开始的第二个节点，那么对于第一个节点，我们还需要释放内存。所以我们定义一个中间变量 tmp 保存 head 最开始的指针，当完成节点移动后，删除 tmp也就是删除了最开始的head。

        while(head != NULL && head->val == val){
            //需要删除头节点
            ListNode* tmp = head;
            head = head->next;//头节点在第二个节点位置了
            delete tmp;//释放空间最开始的头节点
        }

其他节点位置处理的思路是：

由于当前被删除的节点必不可能为头节点，因此删除的思路是，如果该节点需要被删除，那么就让该节点的上一个节点指向被删除节点的下一个节点。同时也需要定义中间变量进行释放内存。因此整个代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        while(head != NULL && head->val == val){
            //需要删除头节点
            ListNode* tmp = head;
            head = head->next;//头节点在第二个节点位置了
            delete tmp;//释放空间最开始的头节点
        }
        //删除非头节点
        ListNode* cur = head;
        while(cur != NULL && cur->next != NULL){
            //数组还在边界内
            if(cur->next->val == val){
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;//让cur指向删除的位置指向被删除位置的下一个
                delete tmp;//释放空间被删除的节点
            }
            else{
                cur = cur->next;
            }
        }
        return head;
    }
};

我们以1虚拟节点操作举例：

这里的思路是：先建立一个虚拟节点，该节点指向第一个节点，那么在后续判断中就不需要再判断头节点了，直接按照删除非头节点的方式。

       ListNode* dummyHead = new ListNode(0);//设置虚拟节点
       dummyHead->next = head;
       ListNode* cur = dummyHead;

然后判断后续非头节点是否需要删除，因此代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
       ListNode* dummyHead = new ListNode(0);//设置虚拟节点
       dummyHead->next = head;
       ListNode* cur = dummyHead;
       while(cur->next != NULL){
           //在有效区间内
           if(cur->next->val == val){
               //需要被删除
               ListNode* tmp = cur->next;
               cur->next = cur->next->next;
               delete tmp;
           }
           else{
               cur=cur->next;
           }
       }
       head = dummyHead->next;//由虚拟节点指向头节点
       delete dummyHead;//释放虚拟节点内存
       return head;
    }
};

相关题目：

203. 移除链表元素 - 力扣（LeetCode）https://leetcode.cn/problems/remove-linked-list-elements/

设计链表

对单链表进行头插，尾插，任意插，任意删，获取任意节点的值。我们将分别介绍这几个部分

方法：
头插：

定义一个虚拟节点指向头节点，定义一个新节点。同时，新节点指向头节点，虚拟节点指向新节点

    void addAtHead(int val) {
        LinkNode *newNode = new LinkNode(val);
        newNode->next = _dummyHead->next;//把新节点指向头节点
        _dummyHead->next = newNode;//把虚拟节点指向新节点
        _size++;//节点数量增加
    }

尾插：

定义一个指针指向虚拟节点，定义一个新节点被最后位置指向

    void addAtTail(int val) {
        LinkNode* newNode = new LinkNode(val);
        LinkNode* cur = _dummyHead;
        //这里cur不一样可以试着代值进去
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }

任意插：

    void addAtIndex(int index, int val) {
        if(index > _size || index < 0){
            return ;
        }
        LinkNode* newNode = new LinkNode(val);
        LinkNode* cur = _dummyHead;
        while(index--){
            cur = cur->next;
        }
        newNode->next = cur->next;;
        cur->next = newNode;
        _size++;
    }

任意删：

    void deleteAtIndex(int index) {
        if(index >= _size || index < 0){
            return ;
        }
        LinkNode* cur =_dummyHead;
        while(index--){
            cur = cur->next;
        }
        LinkNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        _size--;
    }

相关题目：

707. 设计链表 - 力扣（LeetCode）https://leetcode.cn/problems/design-linked-list/

翻转链表

原理：

对于单链表进行元素翻转时，我们利用双指针方法，分别指向前后节点，交换节点指向顺序实现整个链表的翻转

方法：

包括：1双指针法，2递归法实现，两者思路一样，需要注意的是，在翻转之后移动指针时，先移动后指针再移动前指针。

我们现在以双指针举例：

定义一个cur指向前节点赋值为head，定义一个后节点赋值为NULL。因为翻转后，之前的头节点需要指向NULL

        ListNode* cur = head;//后节点
        ListNode* pre = NULL;//前节点

当前节点指向NULL，也就是之前的尾节点时结束循环，同时利用一个中间变量保存cur的下一个节点，因为我们需要把cur的下一个节点赋值给pre，没有中间变量将导致找不到下一个节点了。当完成一次翻转后，后节点，前节点依次前移

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* cur = head;//后节点
        ListNode* pre = NULL;//前节点
        while(cur){
            //当cur指向空结束
            ListNode* temp = cur->next;//保留cur之前的下一个节点
            cur->next = pre;//指针翻转;
            //指针同时前移，先移pre，再cur
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

我们现在以递归举例：

由双指针思路一样，我们递归函数为reverse（），其中传入为reverse（head，NULL），也就是之前的（cur，pre），然后返回pre

 return reverse(head,NULL);

当cur=NULL时结束，返回pre

        if(cur == NULL){
            //结束
            return pre;
        }

定义中间变量和翻转节点，这里和双指针一样

        ListNode* temp = cur->next;
        cur->next = pre;//翻转指针

现在前移节点，按照双指针，先移动pre，再移动cur，因此传入的reverse按照这个样子，总代码如下：

class Solution {
public:
    ListNode* reverse(ListNode* cur,ListNode* pre){
        if(cur == NULL){
            //结束
            return pre;
        }
        ListNode* temp = cur->next;
        cur->next = pre;//翻转指针
        //移动指针
        return reverse(temp, cur);
    }
    ListNode* reverseList(ListNode* head) {
        return reverse(head,NULL);//cur,pre的顺序传入,返回pre

    }
};

相关题目：
206. 反转链表 - 力扣（LeetCode）https://leetcode.cn/problems/reverse-linked-list/

 两两交换链表中的节点

创建虚拟头节点指向头节点，定义一个指针指向虚拟头节点，以及保存 1， 3节点的指针 

        ListNode* dummyHead = new ListNode(0);//虚拟头节点
        dummyHead->next = head;
        ListNode* cur = dummyHead;
            //1.保存 1，3节点
            ListNode* temp1 = cur->next;
            ListNode* temp2 = cur->next->next->next;

判断链表遍历结束，一定要先判断cur->next。否则出现空指针报错

 while(cur->next != nullptr && cur->next->next != nullptr){

 //1.交换cur 和 2

 cur->next = cur->next->next;

 //2.交换1，2

  cur->next->next = temp1;

//3.交换1，3

 temp1->next = temp2;

//cur移动两个，总代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0);//虚拟头节点
        dummyHead->next = head;
        ListNode* cur = dummyHead;
        while(cur->next != nullptr && cur->next->next != nullptr){
            //1.保存 1，3节点
            ListNode* temp1 = cur->next;
            ListNode* temp2 = cur->next->next->next;
            //1.交换cur 和 2
            cur->next = cur->next->next;
            //2.交换1，2
            cur->next->next = temp1;
            //3.交换1，3
             temp1->next = temp2;
            //cur移动两个
            cur = cur->next->next;
        }
        return dummyHead->next;
    }
};

相关题目：
24. 两两交换链表中的节点 - 力扣（LeetCode）https://leetcode.cn/problems/swap-nodes-in-pairs/

删除链表的倒数第N个节点

 方法：

要删除链表中的倒数第n个节点，我们使用：双指针方法。

定义一个虚拟头节点指向head，两个快慢指针指向虚拟节点

        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* fast = dummyHead;
        ListNode* slow = dummyHead;

先让快指针移动n+1个位置，再让快慢指针一起移动，当快指针到了NULL时，此时慢指针在被删除元素的前一个位置。

        while(n-- && fast != NULL){
            fast = fast->next;
            //先让fast移动n
        }
        //fast移动再+1，这样slow在被删除元素前一个
         fast = fast->next;
        //fast slow一起移动，直到fast到NULL
        while(fast != NULL){
            fast = fast->next;
            slow = slow->next;
        }

现在进行元素删除，让slow的next指向被删除元素的下一个，同时释放内存，总代码如下

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* fast = dummyHead;
        ListNode* slow = dummyHead;
        while(n-- && fast != NULL){
            fast = fast->next;
            //先让fast移动n
        }
        //fast移动再+1，这样slow在被删除元素前一个
         fast = fast->next;
        //fast slow一起移动，直到fast到NULL
        while(fast != NULL){
            fast = fast->next;
            slow = slow->next;
        }
        ListNode* temp = slow->next;
        slow->next = slow->next->next;
        delete temp;
        return dummyHead->next;
    }
   
};

相关题目：
19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）icon-default.png?t=M85Bhttps://leetcode.cn/problems/remove-nth-node-from-end-of-list/

链表相交

方法：
求两个链表相交的位置，如果没有就返回空，我们利用一个巧妙办法，先让比较长的链表的头指针移动两个链表的差距长度，然后以长链表开始，遍历两个链表的节点是否一样。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0, lenB = 0;
        //求A，B链表长度
        while(curA != NULL){
            lenA++;
            curA = curA->next;
        }
        while(curB != NULL){
            lenB++;
            curB = curB->next;
        }
        //让curA，curB回到头节点
        curA = headA;
        curB = headB;
        //找到最长链表，设置为A
        if(lenB > lenA){
            swap(lenA,lenB);
            swap(curA,curB);
        }
        //求差距长度
        int gap = lenA - lenB;
        while(gap--){
            curA = curA->next;
            //curA移动gap个长度
        }
        //遍历A，B是否有相同的
        while(curA != NULL){
            if(curA == curB){
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

相关题目：

面试题 02.07. 链表相交 - 力扣（LeetCode）icon-default.png?t=M85Bhttps://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/

环形链表

 方法：

利用双指针实现，题目满足当快慢指针相遇后，同时移动z个距离必定相遇。

根据这个要求：我们做如下工作：

让快慢指针一起移动，并且满足在边界范围内

 while(fast != NULL && fast->next != NULL){
            fast = fast->next->next;
            slow = slow->next;
}

当移动过程中两者相遇，则让两者继续移动，两者必定会碰到

 if(fast == slow){
                ListNode* index1 = head;
                ListNode* index2 = fast;
                while(index1 != index2){
                    //直到两者在移动z个距离碰到
                    index1 = index1->next;
                    index2 = index2->next;
                }

完整代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL){
            fast = fast->next->next;
            slow = slow->next;
            //一直移动快慢指针,直到相遇
            if(fast == slow){
                ListNode* index1 = head;
                ListNode* index2 = fast;
                while(index1 != index2){
                    //直到两者在移动z个距离碰到
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        return NULL;

    }
};

相关题目：

142. 环形链表 II - 力扣（LeetCode）icon-default.png?t=M85Bhttps://leetcode.cn/problems/linked-list-cycle-ii/

别说没办法啊
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现链表的增删查改以及OJ题讲解
m0_69888254的博客
07-29 571
目录 动态申请一个节点 单链表的打印 单链表的尾插 单链表的头插 单链表的尾删 单链表的头删 单链表查找 单链表在pos位置之后插入x 单链表删除pos位置之后的值 单链表的销毁 最后呢，我会挑几道关于链表的OJ题给大家讲解一下 ...
c++ pointer runtime error 指针的奇怪问题 while(head != NULL)
JN102的博客
05-01 982
问题 在leecode做题遇到一个奇怪的问题： 就是链表反转的题，我本来以为很简单，但是while(head != NULL)这行代码报错 错误信息：Line 14: Char 16: runtime error: member access within misaligned address 0x000000000007 for type ‘ListNode’, which requires 8...
链表力扣题解（上）
lihua777的博客
02-02 1504
单链无头无循环链表的基本： （1）链表的结构体： structListNode{ intval; structListNode*next; }; （2）定义指针指向： struct ListNode* n1=head 定义一个链表型的n1的指针指向头地址 （3）指向下一个地址 n1=n1->next; (4)指向该地址所存储的值 n1->val 1：反转链表 思路解析： 定义三个结构体型的指针，*n1，*n2，*...
链表的学习
weixin_73869857的博客
04-16 288
链表的学习
（剑指offer)删除链表的节点
Sljya的博客
10-01 110
删除链表的节点 题目描述：给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。返回删除后的链表的头节点。 思想：本题是删除val值，分为两步：定位节点和修改引用。 1.定位节点：遍历链表，直到找到head->val==val值时跳出，即可找到目标节点。 2.修改引用： 设节点 cur 的前驱节点为 pre ，后继节点为 cur.next ；则执行 pre.next = cur.next ，即可实现删除 cur 节点。 算法流程： 特例处理： 当应删除头节点 head 时，直接返回 h
链表相关算法总结
victor的博客
05-29 2763
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。因为在编写程序时，经常用来评估代码能力--包括代码规范性、完整性、鲁棒性。 本文按照论文按照题目进行距离总结，题目列表如下： 1、环形链表插值问题 2、当前访问节点删除问题 3、链表中荷兰国旗问题 4、**单链表的k区间逆序问题 5、复杂结构链表的复制 6、单链表判断是否有环
算法-链表
weixin_51360664的博客
03-07 298
1.移除链表元素 删除链表中等于给定值 val 的所有节点。 class Solution: def removeElements(self,head,val): dummy_head = ListNode(next=head) cur = dummy_head while cur.next: if cur.next.val == val: cur.next = cur.next.next
基础算法+链表-队列-栈+面试必备+思维训练+编码能力训练
08-07
【链表】 ...总结来说，链表、队列和栈是基础的算法和数据结构，熟练掌握它们对于IT从业者，尤其是面试者，具有极大的价值。通过不断练习，不仅可以提升技术实力，还能增强应对面试和工作中问题的能力。
php数组当链表-php数组和链表的区别总结 数组和链表.pdf
04-18
总结来说，选择数组还是链表取决于具体的应用需求。如果需要高效访问且数据变化不大，数组是更好的选择；如果数据变化频繁，特别是插入和删除操作多，那么链表会更加合适。在实际开发中，理解这些概念有助于编写更...
双链表-循环链表-静态链表.pdf
04-14
总结来说，双链表提供了双向遍历的能力，循环链表在遍历和某些特定操作上具有优势，而静态链表则适用于数据元素数量固定且不支持指针的环境。理解和掌握这些链表类型及其操作，对于理解和编写高效的数据结构算法至关...
链表-使用Python基于链表实现数组栈.zip
03-13
总结起来，这个压缩包文件提供了关于链表和数组栈的知识点，包括链表的基本概念、Python中如何模拟链表、数组栈的LIFO原理以及如何用链表实现数组栈以提高性能。通过学习这些内容，你可以深化对数据结构的理解，提升...
链表-使用Python基于链表实现栈数据结构.zip
03-13
在实际应用中，链表和栈的组合可以帮助解决多种问题，例如回溯算法（用于找到所有可能的解决方案，如八皇后问题）、表达式求值（使用逆波兰表示法）和函数调用堆栈（用于跟踪程序的执行流程）。了解并熟练掌握这些...
双向链表小辣鸡
m0_67910625的博客
05-02 340
初始化 package seqlist; public class DoubleLinkedList { //有效结点的个数 private int size; //当前头节点 private DoubleNode head; //当前尾结点 private DoubleNode tail; public String toString(){ String ret=""; for (DoubleNode x=h
剑指 Offer 18. 删除链表的节点
error311的博客
09-16 153
题目链接：剑指 Offer 18. 删除链表的节点 题意： 给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。 返回删除后的链表的头节点。 注意：此题对比原题有改动 示例 1: 输入: head = [4,5,1,9], val = 5 输出: [4,1,9] 解释: 给定你链表中值为5的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9. 解题思路： 就两个指针，如果出现就将那个节点代替掉 /** * Definiti...
力扣(LeetCode)刷题，简单题(第5期)
不脱发的程序猿
03-02 4066
力扣(LeetCode)定期刷题，每期10道题，业务繁重的同志可以看看我分享的思路，不是最高效解决方案，只求互相提升。
C语言的学习日志2.19
X2573671311的博客
02-20 1831
链表： 链表是一种基础数据结构，采用动态分配储存单元的方式进行储存分配。结构体指针在这上面得到了充分的运用。换句话说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。 创建链表: 首先，要先构造一个结构体，构造结构体一般都用typedef函数，这样方便结构体变量的命名。 typedef struct _node{ int value; struct _node *next; }Node; ...
head-＞next = p；和p=head-＞next；之间的区别
qq_45885219的博客
07-21 6578
对于head->next = p;和p=head->next;之间的区别，可能对于刚接触链表的你有点难理解其实结合图片就很容易理解 其实在说这两个之前我们可以用一个简单的语句来铺垫一下，比如int a=5；我们知道a就是一个整形数值的变量，下面的数值只代表一部分，此时我们令a=5；我们就让a指向5，把5赋值给a. 然后我们再先来说一说head->next = p; 然后我们再来说一说p=head->next;如果理解了上面的那个语句，那这个就不难了 网上对与head->n
栈与队列基本操作
m0_60777643的博客
01-30 3784
一.栈 1.顺序栈操作： 注：栈是一种只在头部进行操作的数据结构，不需要用到中间插入和删除，因此一般日常生活中用顺序表的形式来表示栈，操作可能会更方便。 ① 顺序栈的创建（初始化）： ...
数据结构--二叉树遍历
最新发布
binhyun的博客
07-15 444
（1）前序遍历 （2）定义结构体 （3）前序遍历实现 （4）中序遍历实现 （5）二叉树的节点个数 （6）二叉树树叶节点个数 （7）二叉树的高度 （8）二叉树节点的开辟 （9）建立一个测试二叉树 （10）测试二叉树相关函数的功能 （11）第k层的数据个数 （12）二叉树里面查找节点

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值