算法通关村第一关链表白银挑战笔记

原创 已于 2023-08-29 22:26:58 修改 · 400 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #链表 #笔记 #java

于 2023-08-29 22:07:56 首次发布

 删除链表元素专题

删除特定结点

题目 LeetCode 203

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == vaL 的节点，并返回新的头节点。

/**
 * 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) {

    }
}

输入：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 输出：[]

分析

属于链表删除节点题型，此时就要知道，删除节点时的不同种情况

（1）删除链首结点

步骤简述：

  1. 创建一个新的节点，并为其分配内存空间。
  2. 将新节点的指针域（存储下一个节点的地址）指向当前的头节点。
  3. 将头指针（head）指向新节点的地址，以使得新节点成为新的头节点

（2）删除链中结点

步骤简述：

  1. 创建一个新节点，并为其分配内存空间。
  2. 遍历链表，找到要插入位置的前一个节点。
  3. 将新节点的指针域指向前一个节点原本指向的下一个节点。
  4. 将前一个节点的指针域指向新节点。

（3）删除链尾结点

步骤简述：

  1. 创建一个新节点，并为其分配内存空间。
  2. 将新节点的数据赋值为要添加的数据。
  3. 将新节点的指针域设置为null，表示它是链表的最后一个节点。
  4. 将最后一个节点的指针域指向新节点。

题目给出了头结点head和目标值val，

所以从头结点head开始遍历链表去寻找目标值val去删除链表中的节点

代码

class Solution {  
    public ListNode removeElements(ListNode head, int val) {  
        // 创建一个虚拟头结点  
        ListNode dummyHead = new ListNode(0);  
        // 让虚拟头节点指向链表的头结点head  
        dummyHead.next = head;  
        // 同时创建节点cur也指向虚拟头节点  
        // 也直接指向链表头结点head  
        ListNode cur = dummyHead;  
  
        // 用cur去遍历链表  
        while (cur.next != null){  
            // 符合就删除  
            if (cur.next.val == val){  
                cur.next = cur.next.next;  
            // 不符合就转到下一个  
            } else {  
                cur = cur.next;  
            }  
        }  
        // 返回之前一开始就指向头结点的虚拟节点  
        return dummyHead.next;  
    }  
}
  1. 创建虚拟头节点：
    • ListNode dummyHead = new ListNode(0);：创建一个新的ListNode实例，名为dummyHead，并将它的值设置为0。这个节点是虚拟的，不会实际存储任何数据，只是作为一个辅助工具来简化链表的删除操作。
    • dummyHead.next = head;：将虚拟头节点dummyHead的next指针设置为链表的头节点head，这样就可以通过虚拟头节点来访问整个链表。
  1. 创建当前节点：
    • ListNode cur = dummyHead;：创建一个新的ListNode实例，名为cur，并将它设置为虚拟头节点dummyHead的下一个节点。
  1. 遍历链表：
    • while (cur.next != null) {...}：使用循环遍历链表。循环条件是当前节点的下一个节点不为空。
  1. 删除元素：
    • 在循环的每次迭代中，都会检查当前节点的下一个节点的值是否等于给定的值val。
    • 如果等于，那么就通过cur.next = cur.next.next;将当前节点（即下一个节点）从链表中删除。这实际上跳过了下一个节点，因为它具有特定的值，我们不希望保留它。
    • 如果不等于，那么就通过cur = cur.next;将当前节点移动到下一个节点。继续遍历链表。
  1. 返回结果：
    • 最后，当循环结束时，我们返回虚拟头节点dummyHead的下一个节点，也就是经过删除操作后的链表的头节点。

删除倒数第n个结点

题目 LeetCode 19

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

/**
 * 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) {

    }
}

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

示例 2：

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

示例 3：

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

分析

首先题目没告诉我们链表的长度，只告诉我们头结点和要删除的倒数第N个结点。

所以我们需要找到这个节点，问题就能解决了。

找到结点的方法也分为几种：

第一种

先遍历一遍链表，找到链表总长度L，然后重新遍历，位置L-N+1的元素就是我们要删的。

eg：假设有5个结点，要删除倒数第2个，所以我要删除的是5-2+1个即第4个

第二种

定义first和second两个指针，first先走N步，然后second再开始走，当first走到队尾的时候，second就是我们删除的节点

第三种

使用栈，先将元素全部压栈，然后弹出第N个的时候就是我们要的

要用栈，又要用链表，一个搞不好，全gg，不推荐

代码

第一种，两次遍历

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        // 创建一个虚拟头结点  
        ListNode dummy = new ListNode(0);
        // 让虚拟头节点指向链表的头结点head  
        dummy.next = head;
        // 同时创建节点cur也指向虚拟头节点  
        // 也直接指向链表头结点head 
        ListNode cur = dummy;
        
        //获取链表长度，再遍历到要删除位置的前一个
        int length = getLength(head);
        for (int i = 1; i < length - n + 1; i++){
            cur = cur.next;
        }
        //实现删除
        cur.next = cur.next.next;
        //返回虚拟头结点
        return dummy.next;
    }
    
	//链表长度获取
    public int getLength(ListNode head){
        int length = 0;
        while (head != null){
            length++;
            head = head.next;
        }
        return length;
    }
}

第二种

双指针

class Solution { 
    public ListNode removeNthFromEnd(ListNode head, int n) { 
        // 创建虚拟指针  
        ListNode dummyNode = new ListNode(0); 
        // 将虚拟指针指向头指针  
        dummyNode.next = head;   
        // 创建first指针指向head  
        ListNode first = head;   
        // second指针始终指向dummyNode，也就是始终指向head的前一个节点 
        ListNode second = dummyNode; 

        // 将first指针向后移动n个节点
        for (int i = 1; i <= n; i++) { 
            first = first.next;   
        }  
  
        while (first != null) {   
            first = first.next; // 将first指针向后移动一个节点  
            second = second.next; // 将second指针向后移动一个节点  
        }  
        //删除目标结点
        second.next = second.next.next;
        // 返回dummyNode的下一个节点，也就是删除节点后的链表头节点
        return dummyNode.next; 
    }  
}

删除重复元素

只删除重复的一个

题目 LeetCode 83

给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 

/**
 * 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 deleteDuplicates(ListNode head) {

    }
}

示例 1：

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

示例 2：

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

提示：

  • 链表中节点数目在范围 [0, 300] 内
  • -100 <= Node.val <= 100
  • 题目数据保证链表已经按升序 排列
分析

题目已经保证是升序排列的，所以重复的元素是挨在一起的

即：1、2、2、3、3、4、6、8这样

所以可以直接从头节点遍历，找到重复了就直接删除

代码
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        //判断头结点是否为空
        if (head == null){
            return head;
        }

        //创建节点cur指向head
        //再用cur遍历链表
        ListNode cur = head;
        while (cur.next != null){
            //发现重复删除
            if (cur.val == cur.next.val){
                cur.next = cur.next.next;
            }else{
            //否则转到下一个
                cur = cur.next;
            }
        }
        //返回删除后的头结点
        return head;
    }
}

把所有重复的删除

题目

给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字 。返回 已排序的链表 。

/**
 * 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 deleteDuplicates(ListNode head) {

    }
}

示例 1：

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

示例 2：

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

提示：

  • 链表中节点数目在范围 [0, 300] 内
  • -100 <= Node.val <= 100
  • 题目数据保证链表已经按升序 排列
分析

题目已经保证是升序排列的，所以重复的元素是挨在一起的

即：1、2、2、3、3、4、6、8这样

只是说要把所有重复的都删除

需要在遍历的时候去发现重复元素后，多一层while判断后面的元素也是否重复

注意为指针空情况

代码
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        //判断头结点是否为空
        if (head == null){
            return head;
        }

        //创建虚拟头结点并指向头结点
        ListNode dummy = new ListNode(0, head);
        
        // 同时创建节点cur也指向虚拟头节点  
        // 也直接指向链表头结点head 
        ListNode cur = dummy;
        //再使用cur指针去遍历链表
        while (cur.next != null && cur.next.next != null){
            //当发现重复元素时，先把重复元素记录下来
            if (cur.next.val == cur.next.next.val){
                int x = cur.next.val;
                //在从这重复的节点开始往后遍历
                //看后面的是否也重复，重复就删除
                while (cur.next != null && cur.next.val == x){
                    cur.next = cur.next.next;
                }
            } else {
                //没发现重复元素就转到下一个
                cur = cur.next;
            }   
        }
        //返回虚拟节点指向的头结点
        return dummy.next;
    }
}

最后推荐一个知识星球

编辑

编辑

编辑

详情可至链接

编程导航知识星球 | 编程导航知识星球

https://wx.zsxq.com/mweb/views/joingroup/join_group.html?group_id=51122858222824&secret=218iwimac5qa452q3o6pz2os5ajftbb3&inviter_id=212542158511251&share_from=GroupQRCodeSaved&keyword=11RQPQaqp&abtest_source=ABTest_90

直击高频编程考点：链表知识及经典算法题总结
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
10-24 5万+
了解链表结构，并在单链表或双链表中实现遍历、插入和删除以及分析在单链表或双链表中的各种操作的复杂度，同时附上相关面试考点的基本分类试题库（反转链表、链表中环的检测、链表中环的入口点、删除链表中倒数第K个节点、两个链表的第一个公共节点、链表的中间节点、合并两个有序链表、删除链表中的重复元素、排序链表、K 个一组翻转链表、旋转链表、分隔链表、奇偶链表、合并k个排序链表、链表相加、回文链表判定、回文链表重排、交换相邻节点、删除指定元素、反转链表指定部分、存在回文链表、链表最长递增子序列）
算法通关村第一关——链表白银挑战笔记
weixin_44634559的博客
07-30 609
我们发现拼接后从最后的4开始，两个链表是一样的了，自然4就是要找的节点，所以可以通过拼接的方式来寻找交点。比较特殊的是进行分段处理的时候，例如K个一组处理，此时会用到左闭右开区间，也就是这样子[a,b)，此时需要处理a，但是不用处理b，b是在下一个区间处理的。进一步分析，我们发现两个继续优化的点，一个是上面第一个大while里有三种情况，我们可以将其合并成两个，如果两个链表存在相同元素，第一次出现时使用if (l1.val
《算法通关村第一关——链表白银挑战笔记》
qwquu的博客
08-30 562
主要介绍链表基本的操作，可以借用Hash表来解决相同重复等问题，倒转链表可以考虑栈的数据结构，巧妙的使用双指针找到中间元素，使用双指针找到倒数第k个元素。
算法通关村第一关—链表白银挑战笔记 链表高频面试算法题
weixin_43910861的博客
07-26 527
当fast到达表尾的时候，slow正好到达一半的位置，那么接下来可以从头开始逆序一半的元素，或者从slow开始逆序一半的元素，都可以。让链表长的L1减去链表短的L2得到一个差值|L1-L2|，让L1先走|L1-L2|的步，此时L1和L2的长度已经是一致了，接下来，L1和L2同时向前走，直到遇到第一个相同的结点。常用的数据结构有数组、链表、队、栈、Hash、集合、树、堆。链表A和链表B同时推入两个栈中，再用时出栈，如果出栈的元素相等，则继续出栈，直到出栈元素不同，则上一个元素就是第一个相同的节点。
算法通关村第一关——链表笔记（白银挑战）
Hai_Helloyou的博客
07-19 645
学完就解决了绝大部分情况下的链表双指针问题啦！！
算法通关村第一关-链表白银经典问题笔记
sytdsqzr的博客
10-17 1571
大家好今天来写第一关的白银挑战-链表经典问题.
算法通关村第一关——链表经典问题之白银挑战笔记
retgog的博客
07-18 506
1、先遍历链表得到长度len，k=k%len，需要将进行链表拼接，先寻找旋转后的头结点，fast先走k步，slow与fast再同时走，fast.next走到null时，slow走到倒数第k+1个元素，即旋转后头结点前一个结点，获取slow.next结点（旋转后头结点post），slow.next=null,fast.next=head,返回post。1、创建一个新链表，将两个有序链表进行遍历，比较val值，将更小的结点接入新链表，相同则都接入新链表，一个链表遍历完后，将另一个链表剩下部分都接入新链表。
【算法通关村】第一关链表白银挑战笔记
weixin_72920357的博客
08-31 281
没有思路怎么办？常用的数据结构有数组、链表、队、栈、Hash、集合、树、堆。常用的算法思想有查找、排序、双指针、递归、迭代、分治、贪心、回溯和动态规划等等。
算法通关村第一关——链表白银
大白的Java之旅
07-28 488
链表问题之：找重合节点、判断回文链表
算法通关村第二关——链表反转笔记（白银挑战）
Hai_Helloyou的博客
07-21 440
反转两个数区间的结点。
算法通关村第一关-链表青铜挑战笔记
10-28
源代码
编程导航算法通关村第 1 关|白银 - 四种方法解决两个链表第一个公共子节点-C++
qq_57427154的博客
07-19 1960
使用四种不同的方法来找出两个链表的第一个公共节点，用C++代码进行实现。
头歌平台数据结构与算法 单链表实验 第1关：倒置链表
qq_63924481的博客
10-25 5433
头歌平台教学课堂-《数据结构》实训作业
完全背包 vs 多重背包的优化逻辑
布心老混子
12-02 328
做题时想到完全背包是可以转化成多重背包的，那么多重背包需要二进制优化，完全背包需要吗？
Leetcode 68 搜索插入位置 | 寻找比目标字母大的最小字母
im_AMBER的博客
12-04 1021
你的错误逻辑正确逻辑找到 target 时返回 mid-1找到 target 时，继续向右查找（因为需要「大于」target 的最小字符）target <letters [mid] 时，mid 是候选，需保留，right=mid（左闭右开）或不立即排除 mid循环结束直接返回 letters [0]循环结束后，先判断 left 是否越界：越界则返回 letters [0]，否则返回 letters [left]初始right的取值与「越界判断」不匹配；
欧几里得距离算法-相似度
weixin_45609702的博客
12-04 182
本文介绍了一个计算欧几里得距离的Java方法。该方法接收两个Double数组作为输入，通过计算对应元素差值的平方和再开方，返回两个数组之间的欧几里得距离值。当输入数组长度不一致时，方法会返回0作为默认值。欧几里得距离算法常用于比较两个数组之间的相似度，是数据分析和机器学习中的基础距离度量方法。
C++ ⼀级 2024 年 03 ⽉
weixin_46669997的博客
12-05 21
当 N 为9, 6, 3, 0时，满足条件 N % 3 == 0，因此它们被输出并跟随一个 #。要注意的是，字符串“a+1= ”最后有一个空格，因而输出的内容是：a+1= 2，答案为A。输入21，21%3的结果为0，进入if的分支，因而第4行代码可以被执行。19.【判断题】C++表达式 “10”*2 执行时将报错，因为 “10” 是字符串类型而2是整数类型，它们数据类型不同，不能在一起运算。Cout后面有两个<<，第1个输出字符串5%2=，第2个输出算术运算“5%2”的结果，为1，答案为D。
浅谈：快递物流与算法的相关性（五）
最新发布
Duoya1105的博客
12-05 131
NP-C 的英文全称是 Non-deterministic Polynomial Complete，即多项式复杂程度的非确定性问题。简单的写法是NP=P？，问题就在这个问号上，到底有没有让NP=P的算法，或是如何证明NP≠P。启发式算法的思想是：在不断解决问题的过程中寻找解决问题的最优方案。再举一个通俗的例子：当我们用数字密码解锁手机时，如果我们不知道密码是多少，必须将所有的数字组合依次尝试。这听起来像是一句废话，如果将它抽象一点的表述，就是：能用电脑快速验证一个解的问题，是否也能够用电脑快速地求出解。
[优选算法专题十.哈希表 ——NO.55~57 两数之和、判定是否互为字符重排、存在重复元素]
2401_83386596的博客
12-03 679
两数之和问题的最优解法采用哈希表实现O(n)时间复杂度，通过存储元素值与下标的映射关系，快速查找互补值。字符重排判定问题通过单哈希数组统计字符出现次数，先加后减并实时校验，确保字符种类和数量完全一致。存在重复元素问题使用哈希集合检测重复元素，遍历数组时检查元素是否已存在于集合中。三种解法均利用哈希结构优化查找效率，将时间复杂度从暴力解法的O(n²)降至O(n)，是典型空间换时间策略的工业级实现。
C语言实现一元多项式加减法的动态链表算法
在数据结构的学习与应用中，一元多项式的加减法是一个非常经典且具有代表性的算法实现案例，尤其结合C语言和动态链表的数据组织方式，能够充分体现出链表在处理稀疏数据、动态内存分配以及复杂逻辑操作中的优势。...
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

雨空集

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值