【代码随想录】链表

已于 2024-05-02 10:06:24 修改
阅读量253 收藏 4
点赞数 4
分类专栏： 算法学习笔记 文章标签： leetcode 数据结构
于 2024-04-29 15:04:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42904738/article/details/138309671
版权

基础知识

链表的分类

在这里插入图片描述

链表的存储特点

数组：在内存中连续分布
链表：在内存中散乱地分布在各处，通过指针串联
在这里插入图片描述

链表的定义

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; }
}

203. 移除链表元素

方法一：迭代

不使用虚拟头节点

如果不使用虚拟头节点，则在删除节点时要对“要删除的节点是否为头节点”进行分类讨论:

  • 删除某个节点的做法是：令该节点的前一节点的next指针指向该节点的后一节点。如果该节点是链表头节点（没有前一节点），则直接令head指针指向该节点的后一节点。
  • 由于删除中需要知道要删除节点的前一节点，因此在遍历时使用两个指针一起遍历，快指针指向当前节点，慢指针指向当前节点的前一节点。

注意：在更新pre和cur指针时，如果在本轮迭代中删除了cur节点，就只需要将cur向后移动一位，不需要移动pre

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode pre = null, cur = head;
        while(cur != null){
            if(cur.val == val){
                // 如果cur是要删除的节点
                if(cur == head){
                    // 如果cur是头节点
                    head = cur.next;
                }else{
                    // 如果cur不是头节点
                    pre.next = cur.next;
                }
                // 只需将cur指针向后移动一位
                cur = cur.next;
            }else{
                // 如果cur不是要删除的节点
                // 将两个指针一起向后移动一位
                pre = cur;
                cur = cur.next;
            }
        }
        return head;
    }
}

使用虚拟头节点

使用虚拟头节点可以不用对“要删除的节点是否为链表头节点”进行分类讨论，简化代码编写：

  • 开始遍历链表前创建一个虚拟头节点dummyHead，其next指针指向链表头节点
  • 最终返回dummyHead.next即可

注意：在更新pre和cur指针时，如果在本轮迭代中删除了cur节点，就只需要将cur向后移动一位，不需要移动pre。

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        // 添加一个虚拟头节点
        ListNode dummyHead = new ListNode(0, head);

        ListNode pre = dummyHead, cur = head;
        while(cur != null){
            if(cur.val == val){
                // 如果cur是要删除的节点
                pre.next = cur.next;
                // 只需将cur指针向后移动一位
                cur = cur.next;
            }else{
                // 如果cur不是要删除的节点
                // 将两个指针一起向后移动一位
                pre = cur;
                cur = cur.next;
            }
        }
        return dummyHead.next;
    }
}

方法二：递归

在这里插入图片描述

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        // 递归终点：空链表
        if(head == null){
            return head;
        }

        // 对除了头节点head以外的节点进行删除操作
        ListNode node = removeElements(head.next, val);
        // 判断头节点head是否需要删除（判断head的节点值是否等于给定的val）
        if(head.val == val){
            // 如果head.val等于val，则需要删除头节点
            head = node;
        }else{
            // 如果head.val不等于val，则不需要删除头节点
            head.next = node;
        }
        return head;
    }
}

707. 设计链表

class MyLinkedList {

    ListNode head;

    public MyLinkedList() {
        head = null;
    }
    
    // 获取指定下标位置节点的值
    public int get(int index) {
        ListNode node = getNodeByIndex(index);
        if(node == null){
            return -1;
        }else{
            return node.val;
        }
    }

    // 获取指定下标的节点
    private ListNode getNodeByIndex(int index){
        // 如果当前链表为空
        if(head == null){
            return null;
        }

        // 如果指定下标不合法
        if(index < 0){
            return null;
        }

        // 如果链表不为空、且指定下标合法
        // 从head开始遍历链表，index值代表还需遍历的元素个数
        ListNode curNode = head;
        while(true){
            // 如果index已经减少到0了，说明找到指定下标的节点了
            if(index == 0){
                return curNode;
            }

            // 如果index还没有减少到0，但已经抵达链表结尾了，说明链表中不存在该下标的节点
            if(curNode == null){
                return null;
            }

            // 将遍历指针后移一位，并将index值减少1
            curNode = curNode.next;
            index--;
        }
    }
    
    public void addAtHead(int val) {
        ListNode newNode = new ListNode(val, head);
        head = newNode;
    }
    
    public void addAtTail(int val) {
        // 如果当前数组为空
        if(head == null){
            addAtHead(val);
            return;
        }

        // 找到当前数组中的最后一个元素
        ListNode lastNode = head;
        while(lastNode.next != null){
            lastNode = lastNode.next;
        }
        ListNode newNode = new ListNode(val);
        lastNode.next = newNode;
    }
    
    public void addAtIndex(int index, int val) {
        if(index < 0){
            return;
        }

        if(index == 0){
            addAtHead(val);
        }

        // 找到要插入位置的前一个位置的节点
        ListNode preNode = getNodeByIndex(index - 1);

        if(preNode == null){
            return;
        }

        ListNode newNode = new ListNode(val, preNode.next);
        preNode.next = newNode;
    }
    
    public void deleteAtIndex(int index) {
        if(head == null){
            return;
        }

        if(index < 0){
            return;
        }

        if(index == 0){
            head = head.next;
            return;
        }

        // 找到要插入位置的前一个位置的节点
        ListNode preNode = getNodeByIndex(index - 1);

        if(preNode == null){
            return;
        }

        if(preNode.next == null){
            return;
        }

        preNode.next = preNode.next.next;
    }

    // 链表节点
    class ListNode{
        int val;
        ListNode next;
        ListNode(){}
        ListNode(int val){this.val = val;}
        ListNode(int val, ListNode next){this.val = val; this.next = next;}
    }
}

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

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        // 为了删除倒数第N个节点，需要找到链表的倒数第N+1个节点（即倒数第N个节点的前一节点）
        /* 寻找链表倒数第N+1个节点的思路：
         * 用快慢指针同时遍历链表，fast指针永远比slow指针快n步（即当slow指向第i个节点时，fast指向第i+n个节点）
         * 当fast指针指向链表最后一个节点时，slow指针刚好指向倒数第N个节点的前一节点
         */

        // 添加一个虚拟头节点
        ListNode dummyHead = new ListNode(0, head);

        
        ListNode slow = dummyHead; // 初始化slow指针
        // 初始化fast指针，令其指向第n个节点
        ListNode fast = dummyHead; 
        for(int i=1; i<=n; i++){
            fast = fast.next;
            if(fast == null){
                // 链表中节点个数少于n
                return head;
            }
        }

        // 向后移动指针，直到fast指针指向链表最后一个节点
        while(fast.next != null){
            slow = slow.next;
            fast = fast.next;
        }

        // 删除slow指向节点的下一节点
        slow.next = slow.next.next;

        return dummyHead.next;
    }
}

面试题 02.07. 链表相交

解法一：哈希表

在这里插入图片描述

解法二：双指针

在这里插入图片描述在这里插入图片描述

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        // 如果A和B中有空链表，则两个链表必然没有交点
        if(headA == null || headB == null){
            return null;
        }

        // 指针A先遍历链表A，再遍历链表B
        // 指针B先遍历链表B，再遍历链表A
        ListNode A = headA, B = headB;
        while(A != B){
            A = (A == null ? headB : A.next);
            B = (B == null ? headA : B.next);
        }
        // 两指针相遇
        return A;
    }
}

环形链表

141. 环形链表 Ⅰ

解法一：哈希表

最容易想到的方法是遍历所有节点，每次遍历到一个节点时，判断该节点此前是否被访问过。

具体地，我们可以使用哈希表来存储所有已经访问过的节点。每次我们到达一个节点，如果该节点已经存在于哈希表中，则说明该链表是环形链表，否则就将该节点加入哈希表中。重复这一过程，直到我们遍历完整个链表即可。

解法二：双指针 - 快慢指针

  • 快慢指针：fast每次走两步，slow每次走一步
  • 如果无环：fast指针能够抵达链表末尾的null
  • 如果有环：fast和slow会在环中相遇
public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null){
            return false;
        }

        // fast每次走两步，slow每次走一步
        ListNode slow = head, fast = head.next;
        while(true){
            if(slow == fast){
                // 快慢指针相遇 => 链表中有环
                return true;
            }

            // fast向后走两步
            if(fast == null){
                // fast指针抵达链表末尾的null => 链表中无环
                return false;
            }else{
                fast = fast.next;
            }
            if(fast == null){
                // fast指针抵达链表末尾的null => 链表中无环
                return false;
            }else{
                fast = fast.next;
            }

            // slow指针向后走一步
            slow = slow.next;
        }
    }
}

142. 环形链表 II

如果链表中有环，当二者第一次相遇时：
在这里插入图片描述在这里插入图片描述具体做法：
在这里插入图片描述需要注意的是，这里的第一步其实应该是让fast指向头节点的前一个位置，这样当fast再走a步就可以到达环的入口。
也可以先让fast指向头节点，让slow指向slow.next，然后两个指针再一起走a-1步，但是这时会忽略“第一次相遇时slow指向的正好就是环的入口”这种情况，需要分类讨论。

在这里插入图片描述
在这里插入图片描述

public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head == null){
            return null;
        }

        // fast每次走两步，slow每次走一步
        ListNode slow = head, fast = head.next;
        while(true){
            if(slow == fast){
                // 快慢指针相遇 => 链表中有环
                if(slow != head){
                    fast = head;
                    slow = slow.next;
                    while(fast != slow){
                        fast = fast.next;
                        slow = slow.next;
                    }
                }
                return slow;
            }

            // fast向后走两步
            if(fast == null){
                // fast指针抵达链表末尾的null => 链表中无环
                return null;
            }else{
                fast = fast.next;
            }
            if(fast == null){
                // fast指针抵达链表末尾的null => 链表中无环
                return null;
            }else{
                fast = fast.next;
            }

            // slow指针向后走一步
            slow = slow.next;
        }
    }
}
ZhuYuxi333
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代码随想录 链表
m0_74340589的博客
06-11 392
void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。cur = head 因为链表只能指向下一个节点 那么想删除cur next 直接找到cur 就可以 让cur 指向cur next 的next。int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1。void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
代码随想录链表篇
weixin_44964855的博客
10-26 239
数据结构链表
代码随想录 链表—链表相交
qq_61579397的博客
03-03 600
如果链表相交的话，那肯定最后一段是重合的，所以可以直接按两段链表中长度较短的一个开始遍历。所以先求出A链表和B链表的长度，这里设置curA指针永远指向链表较长的一个链表，如果链表A长度小于B的，那么就交换lenA和lenB，使操作的都是A（较长的一段链表，可能是A也可能是B），求出链表A和B长度的差值，让curA向前移动这个差值的步数，这样两段链表长度得到统一，就开始比较值是否相同，相同就返回当前两指针的一个，不同两个指针就向后移。
代码随想录链表篇——环形链表II
qq_39473176的博客
09-06 224
刷题总结
代码随想录链表篇——反转链表
qq_39473176的博客
09-05 316
刷题总结
代码随想录 链表章节总结
BBTJDDY的博客
07-09 887
每次cur是需要操作的两个节点的其中一个节点。每次记录下cur->next和cur->next->next->next。使用快慢指针，快指针先走n步，然后快慢指针同时走，直到快指针下一个是null，在慢指针这个位置slow->next = slow->next->next。需要用临时变量temp记录下一个需要操作的节点，左边那个尾pre，右边那个是cur，到了cur是nullptr的时候结束。首先求出两个链表的长度，求出二者之差为n，把长的链表头指针移动n步，然后两个头指针同时移动，相等的时候中断返回。
代码随想录：链表
平什么阿的博客
04-19 171
题目来自《代码随想录》 203.移除链表元素 https://leetcode-cn.com/problems/remove-linked-list-elements/ public ListNode removeElements(ListNode head, int val) { if(head == null) return head; ListNode dummy = new ListNode(0, head); ListNode pre = dummy; ListNode cur
代码随想录 链表+代码可本地编译器运行
luckyme_的博客
07-07 593
代码随想录中的链表部分，代码可在本地编译器运行
代码随想录笔记_链表_206反转链表
Erik_Ying的博客
07-19 177
力扣链表206
代码随想录——链表篇
打怪升级
11-09 363
算法
LeetCode142 环形链表 II
daishabby2486的博客
07-25 723
LeetCode142 环形链表 II的解题记录。
leetcode 1555 银行账号概要(postgresql)
weixin_51696882的博客
07-25 1099
力扣银行 (LCB) 帮助程序员们完成虚拟支付。我们的银行在表 Transaction 中记录每条交易信息，我们要查询每个用户的当前余额，并检查他们是否已透支（当前额度小于 0）。 写一条 SQL 语句，查询： user_id 用户 ID user_name 用户名 credit 完成交易后的余额 credit_limit_breached 检查是否透支 （"Yes" 或 "No"） 以任意顺序返回结果表
Leetcode—769. 最多能完成排序的块【中等】
Atticus的博客
07-25 443
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
*算法训练（leetcode）第三十一天 | 1049. 最后一块石头的重量 II、494. 目标和、474. 一和零
最新发布
weixin_43872997的博客
07-25 1355
LeetCode刷题日记
【力扣】：比特位计数
2401_83821949的博客
07-25 392
1.去掉二进制中最左边的1，n&（n-1），如果一次操作以后，就是0，那么这个数是2的倍数。进行几次操作，，变为0，那么就有几个1.3.将x位改为0,~（1<<x）&n。4,x位改为1，1<<x|n.2.拿到最左边的1，n&-n。
力扣34题 双二分查找（简单易懂）
xiaoye7288的博客
07-24 521
正如本题解描述，想清楚三种情况之后，先专注于寻找右区间，然后专注于寻找左区间，左右根据左右区间做最后判断。
Leetcode49. 字母异位词分组(java实现)
Kirihara_Yukiho的博客
07-25 445
第二个for循环的目的是遍历arr，然后并为每个字母打上一个标识，比如eat，经历过这个for循环之后结果就是a1e1t1，并将它作为后续map的key，因为异位词不看顺序只看出现的次数。这里的list应该是同一个list，那么list集合中的数据就是同一组的有效字母异位词。如果没有做过leetcode242题目的同学，可以先把它做了，会更好理解异位词的概念。到此，本题的讲解结束，本道题我建议大家结合代码去看，因为只看思路确实有点思路。我们先看第一个for循环，它的目的是统计eat每个字母出现的次数。
【康复学习--LeetCode每日一题】2844. 生成特殊数字的最少操作
Puppet__的博客
07-25 446
请注意，如果你删除 num 中的所有数字，则 num 变为 0。解释：删除 num[3]、num[4] 和 num[6] ，得到数字 “2900” ，可以被 25 整除。解释：删除数字 num[5] 和 num[6] ，得到数字 “22450” ，可以被 25 整除。解释：删除 num[0] ，得到数字 “0” ，可以被 25 整除。可以证明要使数字变成特殊数字，最少需要删除 2 位数字。可以证明要使数字变成特殊数字，最少需要删除 3 位数字。可以证明要使数字变成特殊数字，最少需要删除 1 位数字。
Leetcode—74. 搜索二维矩阵【中等】
Atticus的博客
07-25 320
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 886
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值