链表-算法总结

最新推荐文章于 2023-04-16 17:11:32 发布
最新推荐文章于 2023-04-16 17:11:32 发布
阅读量420 收藏 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
    评论
专栏目录
单链表的简单操作
z_xiao_xue的博客
06-12 615
单链表是C语言，c++和数据结构中的很重要的一个部分，也有很多实现它的方法，这些算法代码的实现都大同小异，我在这里就用c语言和c++两种不同的方法实现一下链表的基本操作。下面是c++和C语言的两种链表结构的定义 c++方式#include #include #include typedef int DataType; typedef struct SListNode { DataT
C语言实现链表的增删查改以及OJ题讲解
m0_69888254的博客
07-29 562
目录 动态申请一个节点 单链表的打印 单链表的尾插 单链表的头插 单链表的尾删 单链表的头删 单链表查找 单链表在pos位置之后插入x 单链表删除pos位置之后的值 单链表的销毁 最后呢，我会挑几道关于链表的OJ题给大家讲解一下 ...
链表的学习
weixin_73869857的博客
04-16 283
链表的学习
双向链表小辣鸡
m0_67910625的博客
05-02 339
初始化 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 152
题目链接：剑指 Offer 18. 删除链表的节点 题意： 给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。 返回删除后的链表的头节点。 注意：此题对比原题有改动 示例 1: 输入: head = [4,5,1,9], val = 5 输出: [4,1,9] 解释: 给定你链表中值为5的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9. 解题思路： 就两个指针，如果出现就将那个节点代替掉 /** * Definiti...
基础算法+链表-队列-栈+面试必备+思维训练+编码能力训练
08-07
【链表】 ...总结来说，链表、队列和栈是基础的算法和数据结构，熟练掌握它们对于IT从业者，尤其是面试者，具有极大的价值。通过不断练习，不仅可以提升技术实力，还能增强应对面试和工作中问题的能力。
php数组当链表-php数组和链表的区别总结 数组和链表.pdf
04-18
总结来说，选择数组还是链表取决于具体的应用需求。如果需要高效访问且数据变化不大，数组是更好的选择；如果数据变化频繁，特别是插入和删除操作多，那么链表会更加合适。在实际开发中，理解这些概念有助于编写更...
双链表-循环链表-静态链表.pdf
04-14
总结来说，双链表提供了双向遍历的能力，循环链表在遍历和某些特定操作上具有优势，而静态链表则适用于数据元素数量固定且不支持指针的环境。理解和掌握这些链表类型及其操作，对于理解和编写高效的数据结构算法至关...
Java版本算法练习+笔记总结 按照数组-> 链表-> 哈希表->字符串-&gt
最新发布
01-14
Java版本算法练习+笔记总结 按照数组-> 链表-> 哈希表->字符串->栈与队列->树->回溯->贪心->动态规划->图论->高级数据结构进行系统的练习 每道题都有标号和题目链接.zip
链表---链表大集合
07-27
总结来说，链表是数据结构的基础，理解并掌握不同类型的链表及其操作对于编程能力的提升至关重要。无论是在算法设计、数据存储还是系统实现中，链表都发挥着关键作用。通过熟练运用简单链表、带头结点的链表、双向...
移除链表元素（虚拟头结点法）
weixin_45755405的博客
03-14 189
建立一个虚拟头结点，它的下一个节点是head，这样无论我们删除的元素是在头节点还是中间节点我们都可以使用，head->next=head->next->next(举个例子)，就是将该节点的下一个节点指向下一个节点的下一个节点。想要删除元素2这个节点，我们只需要将head节点的下一个节点指向元素3这个节点即可，关键代码：head->next=head->next->next（举个例子）当我们想要删除的元素在头结点时，我们只需要把头结点的下一个节点作为头结点即可。当我们想要删除的节点在中间节点时，例如，
【链表】删除链表的节点（ leetcode18）
不积跬步，无以至千里！
07-07 1027
一、题目 给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。 返回删除后的链表的头节点。 二、题解 本题是一道简单的套路题，首先回忆一下删除链表节点的操作：首先定义两个指针pre、curr；然后从首到尾遍历一次链表，如果要删除当前节点，只需要：pre->next = curr->next。 关键在于：head->val也有可能等于val，所以本题返回的不是head，而是第一个不等于val值的节点。具体做法也很简单，只需在遍历之前，加上： while(head) {
链表中p->next=head->next;语句解析
浅然的专栏
09-30 3万+
在看到一些书上或者网上写的不管是单链表还是双向循环链表等，都会有p->next=q->next;或者p-next=head->next; 这里q是尾指针，head是头指针，p是指向新建结点的指针 该语句作用 这条语句的作用其实就是给新建结点找到它该有的位置 该语句在单链表下的头插法是必须存在的，而在双向循环下可有可无1.单链表的头插法下p-next=head->next;LinkLis
【LeetCode】C++ ：中等题 - 链表 19. 删除链表的倒数第 N 个结点
weixin_44566432的博客
01-26 211
中等题训练开始啦！！！紧张 19. 删除链表的倒数第 N 个结点 难度中等1188 给你一个链表，删除链表的倒数第n个结点，并且返回链表的头结点。 进阶：你能尝试使用一趟扫描实现吗？ 示例 1： 输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5] 示例 2： 输入：head = [1], n = 1 输出：[] 示例 3： 输入：head = [1,2], n = 1 输出：[1] 提示： 链表中结点的数目为sz ...
Java数据结构与算法——链表面试题
baijaiyu的博客
09-13 1310
本文为链表相关面试题，每道题均附讲解及对应连接。 一：反转一个单链表。 链接：206. 反转链表 - 力扣（LeetCode）https://leetcode.cn/problems/reverse-linked-list/description/ 1.题目：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。2. 2.解题 我的思路是：从第二个结点开始，依次将后一个结点的指向改变为指向前一个结点。如果直接改变指向，那么就无法找到下一个结点了，所.....
day14//删除链表的倒数第N个节点
ChenChenYang_int的博客
04-19 351
方法一：暴力法（先遍历得到长度，再用长度减去N即可获得需要删除节点前的节点位置） classSolution{ public: ListNode*removeNthFromEnd(ListNode*head,intn){ ListNode*dummyhead=newListNode(0); dummyhead->next=head; ListNode*cur=head; intm=0...
ListNode list=new ListNode() 、 ListNode list=new ListNode(0) 与 ListNode list=null 的区别
看风起云落的博客
08-17 2万+
ListNode list=new ListNode()初始化一个空节点，无值,不提倡此种写法。 ListNode list=new ListNode(0) 初始化一个节点值为0的空节点，最常用最正规写法 ListNode list=null 为空，什么都没有，一般不这么写； ...
JAVA ListNode链表
热门推荐
摸金校尉的博客
03-06 7万+
链表结构，在Java中用需要自己定义一个ListNode类来生成链表对象。 自定义的ListNode链表类如下： public class ListNode { int val; ListNode next; // 下一个链表对象 ListNode(int x) { val = x; } //赋值链表的值 } leetcode第2题...
考研数据结构算法题总结36页（893+408）
07-13
"该资源是一份针对考研数据结构算法题的总结资料，共计36页，涵盖了893自命题和408考试的相关内容，同时也适合于LeetCode的常见题型。资料中包含了数组、栈、队列、链表、二叉树等多种数据结构的算法题，并涉及到...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值