刷题笔记【链表篇】

已于 2024-07-06 10:42:52 修改
阅读量1.2k 收藏 22
点赞数 29
分类专栏： 算法刷题记录 文章标签： 笔记 链表 数据结构
于 2024-07-05 11:41:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45702045/article/details/140204231
版权

刷题笔记【链表篇】

链表

1、反转链表【LC 206题】

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

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

维护当前节点cur，前一个节点pre，下一个节点nextNode。每次执行一步有cur.next=pre，并把cur、pre、next都往后移。

注意：

每一次循环最后一步都是更新cur的位置，cur=nextNode，最后cur==null，因此判断返回的时候，需要返回pre，而不是cur。

public ListNode reverseList(ListNode head) {
    ListNode cur=head,pre=null,nextNode=cur.next;
    while (cur!=null){
        nextNode=cur.next;
        cur.next=pre;
        pre=cur;
        cur=nextNode;
    }
    return pre;
}

2、回文链表【LC 234题】

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

笔试写法

利用栈先入后出的特性，遍历链表，push节点。判断：从栈中弹出节点，和原来的链表做比对。

  • 时间复杂度：O(n)
  • 额外空间复杂度：O(n)
public boolean isPalindrome(ListNode head) {
    Stack<ListNode> stack=new Stack<>();
    ListNode cur=head;
    while(cur!=null){
        stack.push(cur);
        cur=cur.next;
    }
    while(!stack.isEmpty()){
        if(stack.pop().val!=head.val) return false;
        head=head.next;
    }
    return true;
}
面试写法

快慢指针，利用慢指针找到后半段的链表头，反转后半段链表，再分别从原链表头和反转链表头遍历比对。

  • 时间复杂度：O(n)
  • 额外空间复杂度：O(1)
public boolean isPalindrome(ListNode head) {
    ListNode fast=head.next,slow=head;
    while (fast!=null&&fast.next!=null){
        fast=fast.next.next;
        slow=slow.next;
    }
    ListNode right=reverse(slow.next);
    ListNode left=head;
    while (right!=null){
        if (right.val!=left.val) return false;
        right=right.next;
        left=left.next;
    }
    return true;
}

public ListNode reverse(ListNode head){
    ListNode cur=head;
    ListNode pre=null,next=null;
    while (cur!=null){
        next=cur.next;
        cur.next=pre;
        pre=cur;
        cur=next;
    }
    return pre;
}

3.0 前置问题 荷兰国旗问题【LC 75题】

给定一个包含红色、白色和蓝色、共 n 个元素的数组 nums ，**原地**对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

  • 用三个变量来维护：下一个0应该在的位置left,下一个2应该在的位置right，当前遍历位置idx。也就是[0,left-1]为0；[left,right-1]为1，[right,len-1]为2。【idx，r】为待处理区间。
    • 当nums[idx]==1，表明它已经在正确的位置，因此我们只需要将 idx 向右移动。
    • 当nums[idx]==0，说明它应该放在数组的左边，因此我们将其与 l 位置的元素交换，并将 l 和 idx 都向右移动。
    • 当nums[idx]==2，说明它应该放在数组的右边，因此我们将其与 r 位置的元素交换，并将 r 向左移动。由于交换后 idx 位置的新元素还未检查，所以 idx 暂时不动。

注意：

退出循环条件为idx>right。【idx，r】为待处理区间。退出循环时表明没有待处理的元素。

public class SortColors_75 {
    public void sortColors(int[] nums) {
        int left=0,idx=0,right=nums.length-1;
        while(idx<=right){	//退出循环条件为idx>right
            if(nums[idx]==0) {
                swap(nums,idx++,left++);
            }
            else if (nums[idx]==1) idx++;
            else swap(nums,idx,right--);
        }
    }

    public void swap(int []nums,int left,int right){
        int temp=nums[left];
        nums[left]=nums[right];
        nums[right]=temp;
    }
}

3、单链表荷兰国旗问题

将单向链表按某partition值划分成左边小、中间相等、右边大的形式，并保证节点相对位置不变。

  • 需要6个变量构成3个单链表
    • 小于partition链表的头指针
    • 小于partition链表的尾指针
    • 等于partition链表的头指针
    • 等于partition链表的尾指针
    • 大于partition链表的头指针
    • 大于partition链表的尾指针
  • 遍历链表，判断当前节点应当插入哪个链表
  • 遍历结束，将三个链表依次首尾相接

注意：

需要考虑三个链表中为空的情况，不然可能会出现空指针异常

public static ListNode listPartition(ListNode head,int partition){
        ListNode SH=null;
        ListNode ST=null;
        ListNode EH=null;
        ListNode ET=null;
        ListNode BH=null;
        ListNode BT=null;
        ListNode cur;
    	//遍历链表
        while (head!=null){
            //下面这两部操作，是为了三个链表的结尾都为null
            cur=head.next;
            head.next=null;
            if (cur.val<partition){
                if (SH==null){
                    SH=cur;
                    ST=cur;
                }else {
                    ST.next=cur;
                    ST=cur;
                }
            } else if (cur.val == partition) {
                if (EH==null){
                    EH=cur;
                    ET=cur;
                }else {
                    ET.next=cur;
                    ET=cur;
                }
            }else {
                if (BH==null){
                    BH=cur;
                    BT=cur;
                }else {
                    BT.next=cur;
                    BT=cur;
                }
            }
            head=cur;
        }
        //连接 三个链表 考虑链表为空的情况
        if (ST!=null){
            //如果小于partition链表不为空，就先直接赋值
            ST.next=EH;
            //再考虑等于partition链表是否为空的情况
            ET=ET==null? BH :ST;
        }
    	//先连接再说，后面再判断返回什么
        if (ET!=null){
            ET.next=BH;
        }
        return SH!=null ? SH : (EH!=null ? EH :BH);
    }

4、随机链表的复制【LC 138题】

给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。

例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random --> y 。接收原链表的头节点，返回复制链表的头节点。

笔试解法

利用HashMap，key放原来的节点，value放新建的节点。再次遍历hashmap，建立next和random指针联系。

  • 时间复杂度：O(n)
  • 额外空间复杂度：O(n)
public Node copyRandomList(Node head) {
    HashMap<Node,Node> map=new HashMap<>();
    Node cur=head;
    // 构建 原节点-新节点的map
    while (cur!=null){
        map.put(cur,new Node(cur.val));
        cur=cur.next;
    }
    cur=head;
    //建立 next和random关系
    while (cur!=null){
        map.get(cur).next=map.get(cur.next);
        map.get(cur).random=map.get(cur.random);
        cur=cur.next;
    }
    return map.get(head);
}
面试解法
  • 时间复杂度：O(n)
  • 额外空间复杂度：O(1)

主要分为三步

  1. 先复制节点 A->B->C 变成 A->A’->B->B’->C->C’
  2. 建立 random 关系
  3. split：将A->A’->B->B’->C->C’重新拆分成A->B->C和A’->B’->C’
public Node copyRandomList(Node head) {
    if(head==null) return head;
    Node cur=head;
    //先复制节点 A->B->C 变成 A->A'->B->B'->C->C'
    while (cur!=null){
        Node next=cur.next;
        cur.next=new Node(cur.val);
        cur.next.next=next;
        cur=next;
    }
    //建立 random 关系
    cur=head;
    while (cur!=null){
        cur.next.random=cur.random==null? null : cur.random.next;
        cur=cur.next.next;
    }
    //split
    cur=head;
    Node headNew=cur.next;
    Node curNew=cur.next;
    while (cur!=null){
        cur.next=cur.next.next;
        cur=cur.next;
        curNew.next= cur==null? null :cur.next;
        curNew=curNew.next;
    }
    return headNew;
}

5、环形链表【LC 141题】

给你一个链表的头节点 head ，判断链表中是否有环。

  • 使用快慢指针，如果快慢指针相遇了说明链表有环，快指针遇到null说明链表无环
public boolean hasCycle(ListNode head) {
    if(head==null) return false;
    ListNode fast=head.next;
    ListNode slow=head;
    while(fast!=slow){
        if(fast==null||fast.next==null)
            return false;
        fast=fast.next.next;
        slow=slow.next;
    }
    return true;
}

6、环形链表【LC142题】

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

  • 和上题类似，使用快慢指针
  • 找环的入口时，固定方法：

slow=slow.next，fast=head，然后两者一起往后走，每次走一步，相遇点即为环的入口

public ListNode detectCycle(ListNode head) {
    if(head==null) return null;
    ListNode fast=head.next;
    ListNode slow=head;
    while(fast!=slow){
        if(fast==null || fast.next==null) return null;
        fast=fast.next.next;
        slow=slow.next;
    }
    slow=slow.next;
    fast=head;
    while(fast!=slow){
        fast=fast.next;
        slow=slow.next;
    }
    return slow;
}

以上是一些铺垫，考虑 相交链表 这个大问题。

相交链表：两个链表有交点返回交点，无交点返回null。

根据有环、无环分为以下几种情况：

  1. 两个链表都无环【第七题】
  2. 一个链表有环，一个链表无环【这样的情况，两个链表不会有交点(如果有交点，就会存在一个节点有两个next指针的情况)】
  3. 两个链表都有环【第八题】

7、相交链表【LC 160题】

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

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

在这里插入图片描述

解题思想：

  1. 求出两个链表的长度差n
  2. 让长的链表先走n步
  3. 两个链表一起往后走，如果两链表相交，两者会同时走到交点；如果不相交，两者会同时走到null
//两个链表都无环
public ListNode getIntersectionNode1(ListNode headA, ListNode headB) {
    int n=0;
    ListNode curA=headA;
    ListNode curB=headB;
    //求出链表A和链表B的长度差
    while (curA!=null){
        curA=curA.next;
        n++;
    }
    while (curB!=null){
        curB=curB.next;
        n--;
    }
    curA=n>0?headA:headB;   //curA保存长的链表
    curB=curA==headA?headB:headA;
    n=Math.abs(n);
    // 长链表先往前走n步
    while (n>0){
        curA=curA.next;
    }
    // 如果两链表相交，两者会同时走到交点；如果不相交，两者会同时走到null
    while (curA!=curB){
        curA=curA.next;
        curB=curB.next;
    }
    return curA;
}

8、相交链表【两个链表都有环】

分为三种情况：
在这里插入图片描述

  1. 两个有环链表不相交
  2. 两个链表共用一个入环节点
  3. 两个链表共用一个环，但是入环节点不一致

解决方案：

传入第一个链表头head1，第一个链表入环节点loop1；第二个链表头head2，第二个链表入环节点loop2；

  1. 如果loop1==loop2，说明为同一个环，解法和第七题类似，做题时以loop1结尾而不是null结尾
  2. 如果loop1!=loop2，是1或3情况，这时将loop1再转一圈，如果转的过程碰到loop2了，说明为第三种情况；如果转了一圈没有碰到，说明这两个链表不相交。
//两个链表都有环
public ListNode getIntersectionNode2(ListNode headA, ListNode headB) {
    ListNode curA=headA;
    ListNode loop1=detectCycle(headA);	//链表A的环入口
    ListNode curB=headB;
    ListNode loop2=detectCycle(headB);	//链表B的环入口
    if (loop1==loop2){
        int n=0;
        while(curA!=loop1) n++;
        while (curB!=loop2) n--;
        curA = n>0 ? headA : headB;
        curB = curA==headA ? headB : headA;
        n=Math.abs(n);
        while (n>0){
            curA=curA.next;
            n--;
        }
        while (curA!=curB){
            curA=curA.next;
            curB=curB.next;
        }
        return curA;
    }else {
        curA=loop1.next;
        while (curA!=loop1){
            if (curA==loop2) return loop2;
            curA=curA.next;
        }
    }
    return null;
}
Cutewr
关注
专栏目录
力扣刷题笔记链表篇1
wuliwlll的博客
12-21 213
力扣刷题笔记链表篇1
力扣刷题笔记链表篇2
wuliwlll的博客
12-24 179
力扣刷题笔记链表篇2.
【刷题笔记】链表篇
bandaoliunian_的博客
07-16 453
利用hashSet先把第一个链表中的节点都装进去，然后从第二个链表的头开始遍历，看看是否hashSet包含这个节点，如果包含，第一个找到的节点就是我们要找的。那么我们就可以让他们的尾巴对齐，然后长的那个链表跳到和短的链表相同的位置，再一起向后跳，每跳一次比较这两个节点是否相等（val和next都要相等），直到找到为止。3）方法三，采用了双指针的做法。它的思路其实和方法一是一致的，本质上还是让两个链表的尾巴对齐，然后到了两个链表一样长的位置，一起往后跳，直到找到第一个相同的节点。
【刷题笔记】链表篇2
bandaoliunian_的博客
07-17 262
这道题的思路非常的暴力，就是从链表头部往后遍历，如果遇到两个节点的值一样，就把这两个节点同时去除掉，然后把这个节点的值记录一下，继续往后遍历，如果有和这个值相等的节点，继续去除。但是，一个根本原因就是：“只有两个节点的值先相等了，才有三个节点的值和他们相等的机会”，所以我们可以只统计有两个节点的值相等的，并不需要频繁去更新这个变量。所以，用map记录，只要有前一个节点指向它，就给它的value＋1，当出现2的时候，这个节点就是我们要找的。注意：这么做一定要把虚拟头节点加上，因为有可能第一个节点就入环了。
Leetcode 刷题笔记 链表
爱学习的大叔的博客
08-27 79
链表：通过链将结点们连接起来。 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址）。 链表与顺序表都属于线性表。 ...
算法刷题笔记--链表篇
Petrichorzncu的博客
06-25 270
注意要先写cur->next,因为如果先写了cur->next->next，假如此时cur->next==null，cur->next->next会出现空指针报错。因为设计链表中所有的方法都是自己写的，所以有可能出现的问题是，实际问题与所表现出来的问题不一致。例如：插入算法写错了，但是运行报错是在取值算法中体现。在链表第index个节点前面插入一个节点。获取链表第index个节点的数值。删除链表的第index个节点。在链表的最前面插入一个节点。在链表的最后面插入一个节点。
LeetCode刷题笔记 链表 遍历链表
王清欢的博客
11-11 3122
160 相交链表 给定两个链表，判断它们是否相交于一点，并求这个相交节点。 输入是两条链表，输出是一个节点。如无相交节点，则返回一个空节点。 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Intersected at ‘8’ 解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1
LeetCode刷题笔记 链表 链表的基础操作
王清欢的博客
11-09 3938
链表简介 ​ 链表是由节点和指针构成的数据结构，每个节点存有一个值，和一个指向下一个节点的指针，因此很多链表问题可以用递归来处理。不同于数组，链表并不能直接获取任意节点的值，必须要通过指针找到该节点后才能获取其值。同理，在未遍历到链表结尾时，我们也无法知道链表的长度，除非依赖其他数据结构储存长度。
力扣刷题笔记——反转链表
bairui6666的博客
12-06 1359
经典问题反转链表这里给出四种解法。
labuladong的算法秘籍+刷题笔记V2.0
09-17
《labuladong的算法秘籍+刷题笔记V2.0》是针对计算机程序员面试和技能提升的一份宝贵资源，特别关注于刷题、算法和数据结构的学习。这套资料包含两部分：《labuladong的刷题笔记V2.0(力扣版).pdf》和《labuladong的...
【Leetcode刷题笔记之链表篇】234. 回文链表
大家好我叫张同学
01-15 1255
给你一个单链表的头节点 `head` ，请你判断该链表是否为`回文链表`。 如果`是`，返回 `true` ；否则，返回` false` 。 具有对称性的链表就具有回文结构 如果是单数个结点，中间的结点无需考虑，如果其他结点对称肯定是回文结构 例如：1 2 3 1 2 也是回文结构 这里借助求链表倒数第k个结点的思路。 只要链表的.....
【Leetcode刷题笔记之链表篇】141. 环形链表
大家好我叫张同学
01-18 905
给你一个链表的头节点 `head` ，判断链表中`是否有环`。 如果链表中有某个节点，可以通过`连续跟踪` `next `指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数` pos `来表示链表尾连接到链表中的位置（索引从` 0` 开始）。如果` pos` 是` -1`，则在该链表中没有环。 注意：`pos` 不作为参数进行传递，仅仅是为了标识链表的实际情况。 如果链表中存在环，则返回 `true` 。 否则，返回 `false` 。
【Leetcode刷题笔记之链表篇】876. 链表的中间结点
大家好我叫张同学
01-10 1145
给定一个头结点为 `head` 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。 要得到中间结点，我们很容易想到的一种方法就是：先`遍历一遍链表`，求出`链表长度`，然后再从头开始，`走到中间结点`去，返回中间结点......
（笔记）第三期书生·浦语大模型实战营（十一卷王场）--书生入门岛通关第2关Python 基础知识
haidizym的博客
10-02 448
学员闯关手册：https://aicarrier.feishu.cn/wiki/ZcgkwqteZi9s4ZkYr0Gcayg1n1g?课程视频：https://www.bilibili.com/video/BV1mS421X7h4/课程文档：https://github.com/InternLM/Tutorial/tree/camp3/docs/L0/Python。
江科大笔记—LED闪烁& LED流水灯& 蜂鸣器
m0_62005595的博客
09-28 485
LED闪烁& LED流水灯& 蜂鸣器
【韩顺平Java笔记】第6章：数组、排序和查找
最新发布
随手写写
10-02 715
排序是将多个数据，依指定的顺序进行排列的过程。
Spring（学习笔记）
m0_74728220的博客
10-02 972
context:annotation-config/>是 Spring 配置文件中的一个标签，用于开启注解配置功能。这个标签可以让 Spring 容器识别并处理使用注解定义的 bean。例如，可以使用 @Autowired 注解自动装配 bean，或者使用 @Component 注解将类标记为 bean 等。为什么加载上下文的时候，被包含的Bean它的构造函数的代码会执行呀？好像是很多代码都执行了！！！没有无参构造，有有参构造会报错！也就是说必须要有无参构造！这是为什么呀！
Elasticsearch学习笔记(2）
m0_74293254的博客
09-28 1226
创建索引: 使用 PUT 请求来定义索引及其映射。创建文档: 使用 POST 请求将数据添加到索引。读取文档: 使用 GET 请求获取特定文档。更新文档: 使用 POST 加上 _update 操作来修改现有文档。删除文档: 使用 DELETE 请求删除指定文档。删除索引: 使用 DELETE 请求删除整个索引。请求方式：POST请求格式：/{索引库名}/_doc/文档id示例：POST /my_index/_doc/1 { "field": "value" }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值