算法——链表王

最新推荐文章于 2024-07-12 18:02:43 发布
最新推荐文章于 2024-07-12 18:02:43 发布
阅读量2k 收藏 56
点赞数 52
文章标签： 算法 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43660290/article/details/136561495
版权

链表刷题详解

203.移除链表元素

力扣题目链接(opens new window)

题意：删除链表中等于给定值 val 的所有节点。

示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5]

示例 2： 输入：head = [], val = 1 输出：[]

示例 3： 输入：head = [7,7,7,7], val = 7 输出：[]

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummy =new ListNode(-1);
        dummy.next=head;
        ListNode cur =head;
        ListNode pre =dummy;
        while( cur != null){
            if(cur.val ==val){
              pre.next=cur.next;
            }else{
                 pre=cur;
            }
              cur =cur.next;
                
            }
        
        return dummy.next;
    }
}

删除时需要知道前面一个节点和当前节点，如果不等于只需 pre =cur 就可以了，cur =cur.next则是等于不等于都要执行的。

707.设计链表

力扣题目链接(opens new window)

题意：

在链表类中实现这些功能：

  • get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
  • addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
  • addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
  • addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
  • deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。
class LinkNode{
    int val;
    LinkNode next;
    LinkNode(){}
    LinkNode(int val){
        this.val =val;
    }
}

class MyLinkedList {
    int size;
    LinkNode head;
    public MyLinkedList() {
        size =0;
        head = new LinkNode(0);
    }
    
    public int get(int index) {
       if(index<0 || index>size-1) return -1;
        LinkNode cur=head.next;
            while(index>0){
                cur=cur.next;    
                index--;
            }
            return cur.val;
    }
    
    public void addAtHead(int val) {
        LinkNode newNode = new LinkNode(val);
        newNode.next=head.next;
        head.next=newNode;
        size++;
        // LinkNode cur =head.next;
        // LinkNode pre =head;
        // LinkNode valNode =new LinkNode(val);
        // valNode.next=cur;
        // pre.next=valNode;
        // size++;
    }
    
    public void addAtTail(int val) {
        LinkNode tmp = head;
        LinkNode newNode =new LinkNode(val);
        while(tmp.next !=null){
            tmp=tmp.next;
        }
        tmp.next=newNode;
        newNode.next=null;
        size++;
    }
    
    public void addAtIndex(int index, int val) {
         if (index > size) {
            return;
        }
        if (index < 0) {
            index = 0;
        }
        LinkNode newNode =new LinkNode(val);
        LinkNode pre =head;
        LinkNode cur =head.next;
        while(index>0){
            pre=pre.next;
            cur=cur.next;
            index--;
        }
        newNode.next= cur;
        pre.next= newNode;
        size++;
    }
    
    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        LinkNode pre = head;
        LinkNode cur = head.next;
        while(index>0){
            index--;
            pre= pre.next;
            cur=cur.next;
        }
        pre.next=cur.next;
        size--;
    }
}

PS:要学会定义链表

206.反转链表

力扣题目链接(opens new window)

题意：反转一个单链表。

示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre =null;
        ListNode cur =head;
         ListNode tmp;
        while(cur !=null){
            tmp =cur.next;
            cur.next= pre;
            pre =cur ;
            cur =tmp;
        }
        return pre;
    }
}

PS:无需虚拟头结点，直接操作即可，需要一个tmp来保存当前的下一个节点，本来null在最后面，反转后要在最前面

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

力扣题目链接(opens new window)

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode(-1,head);
        ListNode cur =dummy;
        ListNode firstNode ;
        ListNode secondNode ;
        ListNode tmp;
        while(cur.next!=null && cur.next.next !=null){
            tmp =cur.next.next.next;
           firstNode =cur.next;
           secondNode = cur.next.next;
          
           cur.next= secondNode;
           secondNode.next=firstNode;
           firstNode.next=tmp;
           cur=firstNode;
         }
        return dummy.next;
    }
}

PS:做这种交换节点最好要画图，这题需要虚拟头结点，和上一题不同的是，这题需要返回第一个节点的值，就是dummy.next，而上一题反转链表后的第一个节点就是NULL.cur=firstNode中因为second和first已经换过位置了，所以相当于cur前进了两个，因为用到了cur.next.next.next;，所以要保证cur.next.next不为null，当然前提是cur.next不为null

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

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

力扣题目链接(opens new window)

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

进阶：你能尝试使用一趟扫描实现吗？

示例 1：

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

输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5] 示例 2：

输入：head = [1], n = 1 输出：[] 示例 3：

输入：head = [1,2], n = 1 输出：[1]

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(-1,head);
        ListNode fastNode=dummy;
        ListNode slowNode=dummy;
        while(n>0){
            fastNode=fastNode.next;
            n--;
        }
        fastNode=fastNode.next;
        while(fastNode!=null ){
            fastNode=fastNode.next;
            slowNode=slowNode.next;
        }
        slowNode.next=slowNode.next.next;
         return dummy.next;
    }
   
}

PS：寻找倒数节点时可以使用双指针的方法

双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。

思路是这样的，但要注意一些细节。

分为如下几步：

  • 首先这里我推荐大家使用虚拟头结点，这样方便处理删除实际头结点的逻辑，如果虚拟头结点不清楚
  • 定义fast指针和slow指针，初始值为虚拟头结点，如图：

img

  • fast首先走n + 1步 ，为什么是n+1呢，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作），如图： img
  • fast和slow同时移动，直到fast指向末尾，如题： img
  • 删除slow指向的下一个节点，如图： img

面试题 02.07. 链表相交

同：160.链表相交

力扣题目链接(opens new window)

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

img

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

示例 1：

img

示例 2：

img

示例 3：

imgimg

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode cur1=headA;
        ListNode cur2=headB;
        int lenA =0;
        int lenB =0;
        while(cur1!=null){
            cur1=cur1.next;
            lenA++;
        }
          while(cur2!=null){
            cur2=cur2.next;
            lenB++;
        }
         ListNode tmpA =headA;
        ListNode tmpB =headB;
        if(lenA>lenB){
            int n =lenA -lenB;
            while(n>0){
                tmpA=tmpA.next;
                n--;
            }
        }else{
             int n =lenB -lenA;
           
            while(n>0){
                tmpB=tmpB.next;
                n--;
            }
        }
            while(tmpA!=null){
                if(tmpA==tmpB) return tmpA;
                tmpA=tmpA.next;
                tmpB=tmpB.next;
                
            }
        
            return null;
    }
}

PS:这题较为简单，因为比的是地址，所以不用考虑值相等而非地址相等的情况，可以先分别算出两个链表的长度，让长的链表先移动长度之差的距离，然后再一一判断两个指针是否相等，注意if(tmpAtmpB) return tmpA;要放在一开始就执行，因为公共节点可能是移动后的第一个节点

142.环形链表II

力扣题目链接(opens new window)

题意： 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

循环链表

思路是定义一个快指针移动2个单位，定义一个慢指针每次移动一个单位，如果最后快指针与慢指针相等，则可以判断有环，若最后快指针指向了null，则证明该链表没有环了，接下来判断入环的第一个节点，需要使用数学的方法

如果有环，如何找到这个环的入口

此时已经可以判断链表是否有环了，那么接下来要找这个环的入口了。

假设从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点 再到环形入口节点节点数为 z。 如图所示：

img

那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。

因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：

(x + y) * 2 = x + y + n (y + z)

两边消掉一个（x+y）: x + y = n (y + z)

因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。

所以要求x ，将x单独放在左面：x = n (y + z) - y ,

再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。

先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。

当 n为1的时候，公式就化解为 x = z，

这就意味着，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。

也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。

让index1和index2同时移动，每次移动一个节点， 那么他们相遇的地方就是 环形入口的节点。

动画如下：

142.环形链表II（求入口）

那么 n如果大于1是什么情况呢，就是fast指针在环形转n圈之后才遇到 slow指针。

其实这种情况和n为1的时候 效果是一样的，一样可以通过这个方法找到 环形的入口节点，只不过，index1 指针在环里 多转了(n-1)圈，然后再遇到index2，相遇点依然是环形的入口节点。

public 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 tmp2 =fast;
                ListNode tmp = head;
                while(tmp!=tmp2){
                    tmp2=tmp2.next;
                    tmp= tmp.next;
                }
                return tmp;
            }
        }
        return null;
    }
}

  ListNode fast = head;
    ListNode slow =head;
    while(fast!=null && fast.next !=null){
        fast=fast.next.next;
        slow=slow.next;
        if(fast==slow){
            ListNode tmp2 =fast;
            ListNode tmp = head;
            while(tmp!=tmp2){
                tmp2=tmp2.next;
                tmp= tmp.next;
            }
            return tmp;
        }
    }
    return null;
}

}
NewbieQiu
关注
  • 52
    点赞
  • 踩
  • 56
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
前端必会算法——链表的逆置
qq_63664183的博客
04-01 539
链表的逆置 代码演示： function Node(value) { this.value = value; this.next = null; } var node1 = new Node(1); var node2 = new Node(2); var node3 = new Node(3); var node4 = new Node(4); var node5 = new Node(5); node1.next = node2; node2.next = node3; node3.nex
算法系列——链表的奇偶重排
BridgeGeorge
05-06 771
题目 给定单链表的头节点 head ，将所有索引为奇数的节点和索引为偶数的节点分别组合在一起，然后返回重新排序的列表。 第一个节点的索引被认为是 奇数 ， 第二个节点的索引为 偶数 ，以此类推。 题目链接： https://leetcode-cn.com/problems/odd-even-linked-list/ 思路 双指针法，注意指针的指向。 代码 class Solution { public ListNode oddEvenList(ListNode head) { if
算法——链表
m0_74206393的博客
05-29 697
链表
数据结构与算法——链表
time_silence的博客
01-19 606
在计算机科学中，链表是数据元素的线性集合，其每个元素都指向下一个元素，元素存储上并不连续。链表内有一种特殊的节点称为哨兵（Sentinel）节点，也叫做哑元（ Dummy）节点，它不存储数据，通常用作头尾，用来简化边界判断。
算法通关——链表反转
m0_53178989的博客
11-27 51
【代码】算法通关——链表反转。
数据结构与算法——链表（双向链表，顺序表与链表的比较)
weixin_68773927的博客
10-25 1030
在双向链表中有此操作（如：ListLength，GetElem等）因此涉及一个方向的指针。故它们的算法与线性表相同，但在插入，删除时则需要同时修改两个方向上的指针，两者的操作的时间复杂度均为T(n)=O(n)双向链表：在单链表的每个结点里在增加一个指向其直接前驱的指针域prior 这样链表就形成了有两个方向不同的链。p的后继结点的前驱结点为自身。即：p的前驱结点的后继结点为它自身。
算法与数据结构——链表
qq_47917118的博客
03-18 263
链表 存储结构 顺序存储:地址连续，用数组 链式存储:地址不连续，用指针(引用，面向对象) 链表 链表中的每一个元素称为“结点”，单链表中每个结点都应包括两个部分：一个是需要用到的实际数据data；另一个就是存储下一个结点地址的指针，即数据域和指针域；而双向链表中，每个结点包括存储其上一个结点地址的指针，用到的数据data和存储下一个结点的指针。数据结构中的每一个数据结点对应于一个存储单元，这种储存单元称为储存结点，也可简称结点。 ———————————————— data为实际存放的数据，next为存
数据结构与算法——链表(头插法，尾插法，循环链表）
weixin_68773927的博客
10-23 2355
注意：由于循环链表没有NULL指针，故涉及遍历操作时，其终止条件就不再像非循环链表那样判断p或p-->next是否为空，而是判断它们是否等于头指针）循环链表：是一种头尾相接的链表（即:表中最后一个结点的指针域指向头结点，整个链表形成一个环状）初始时，r同L均指向头节点，每读入一个数据元素则申请一个新结点，将新结点插入到尾部结点后，r指向新结点。从一个空表L开始，将新结点逐个插入到链表的尾部，尾指针r指向链表的为节点。循环链表的写发与单链表类似 只需改变循环条件。例如：带尾指针循环链表的合并。
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构与算法——链表（三）
caicaptain
05-31 142
讲解数据结构与算法——链表（三）
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
Python实现数据结构与算法——反转链表
12-21
反转链表是数据结构与算法领域中的一个经典问题，它要求我们改变链表节点的指向，使得原本顺着一个方向的链表变成逆序。在这个问题中，我们可以采用两种方法来解决：迭代和递归。 首先，让我们详细讲解迭代的解题...
C语言——链表的归并_c语言链表详解
12-21
用c语言写链表归并
算法和数据结构——链表.pdf
08-07
#资源达人分享计划#
数据结构与算法 —— Java 实现（链表）
01-21
数据结构与算法 —— Java 实现（链表）一、单链表1.1 链表的定义1.2 链表添加一个新的节点1.3 判断当前节点是否为最后一个节点 （isLast）1.4 删除下一节点 （removeNext）1.5 显示节点信息（show）1.6 插入一个...
36. Adam 算法详解
qq_41238579的博客
07-10 959
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
函数模板与类模板
程序员_小兵
07-12 1545
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
最新发布
m0_74586426的博客
07-12 686
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
【排序 - 堆排序】
2302_80393814的博客
07-10 543
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
高级线性表——静态链表
05-19
静态链表是一种使用数组来实现链表的数据结构。它的本质是利用数组来描述链表中结点之间的关系，数组中的每个元素存储着链表中一...静态链表支持链表基本操作，如插入、删除、查找等，具体实现可以参考链表的相关算法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值