代码随想录一刷day03

原创 已于 2023-05-28 13:12:24 修改 · 63 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #leetcode #数据结构

于 2023-05-26 22:24:36 首次发布
本文介绍了三种不同的方法来实现力扣203题的移除链表元素，包括添加虚拟节点、不添加虚拟节点以及不带前置指针的情况。接着讨论了力扣707题的设计链表，通过单链表和双链表实现基本操作。最后，讲解了力扣206题的反转链表，给出了头插法、双指针法和递归解法。所有方法都关注于如何高效地操作链表节点。

提示：代码随想录一刷03day

文章目录

前言

添加虚拟头结点方便操作

一、力扣203移除链表元素

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 removeElements(ListNode head, int val) {
       ListNode newHead = new ListNode(-1,head);
       ListNode pro = newHead;
       ListNode p = head;
       while(p!=null){
           if(p.val==val){
               p = p.next;
               pro.next = p;
           }else{
               pro.next = p;pro = p;
               p = p.next;
           }
       }
       return newHead.next;
    }
}

2.不添加虚拟节点操作

/**
 * 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) {
       while(head!=null&&head.val==val){
           head = head.next;
       }
       while(head==null){
           return null;
       }
       ListNode pro = head;
       ListNode p = head.next;
       while(p!=null){
           if(p.val==val){
               p = p.next;
               pro.next = p;
           }else{
               pro.next = p; pro = p;
               p = p.next;
           }
       }
       return head;
    }
}

3.不添加虚拟节点&&不带前置指针

/**
 * 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) {
       while(head!=null&&head.val==val){
           head = head.next;
       }
       while(head==null){
           return null;
       }
       ListNode p = head;
       while(p.next!=null){
           if(p.next.val==val){
               p.next = p.next.next;
           }else{
               p = p.next;
           }
       }
       return head;
    }
}

二、力扣707设计链表

链表的操作，主要还是在于，附加一个头结点，方便操作

1.单链表

class MyLinkedList {
    int size;
    ListNode head;
    
    public MyLinkedList() {
        this.size = 0;
        this.head = new ListNode(0,null);
    }
    
    public int get(int index) {
        if(index >= this.size || index < 0){
            return -1;
        }
        ListNode p = head;
        for(int count = 0; count <= index; count++){
            p = p.next;
        }
        return p.val;
    }
    
    public void addAtHead(int val) {
        ListNode e = new ListNode(val, null);
        e.next = head.next;
        head.next = e;
        this.size++;
    }
    
    public void addAtTail(int val) {
        ListNode p = head;
        for(int count = 0;count<size; count++){
            System.out.println(p.val);
            p = p.next;
        }
        p.next = new ListNode(val, null);
        this.size++;
    }
    
    public void addAtIndex(int index, int val) {
        ListNode p = head;
        if(index >= 0 && index <= size){
            for(int count = 0;count<index;count++){
                p = p.next;
            }
            ListNode e = new ListNode(val,null);
            e.next = p.next;
            p.next = e;
            this.size++;
        }
    }
    
    public void deleteAtIndex(int index) {
        ListNode p = head;
        if(index >= 0 && index < size){
            for(int count = 0;count<index;count++){
                p = p.next;
            }
            p.next = p.next.next;
            this.size--;
        }
    }
}
class ListNode{
    int val;
    ListNode next;
    public ListNode(){}
    public ListNode(int val, ListNode next){
        this.val = val;
        this.next = next;
    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

2.双链表

class MyLinkedList {
    int size;
    DListNode head, tail;
    
    public MyLinkedList() {
        this.size = 0;
        this.head = new DListNode(0);
        this.tail = new DListNode(0);
        this.head.next = this.tail;
        this.tail.prev = this.head;
    }
    
    public int get(int index) {
        if(index >= this.size || index < 0){
            return -1;
        }
        DListNode p = head;
        for(int count = 0; count <= index; count++){
            p = p.next;
        }
        return p.val;
    }
    
    public void addAtHead(int val) {
        this.addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        this.addAtIndex(this.size, val);
    }
    
    public void addAtIndex(int index, int val) {
        DListNode p = head;
        if(index >= 0 && index <= size){
            for(int count = 0;count<index;count++){
                p = p.next;
            }
            DListNode e = new DListNode(val);
            e.next = p.next;
            p.next.prev = e;
            e.prev = p;
            p.next = e;
            this.size++;
        }
    }
    
    public void deleteAtIndex(int index) {
        DListNode p = head;
        if(index >= 0 && index < size){
            for(int count = 0;count<index;count++){
                p = p.next;
            }
            p.next = p.next.next;
            p.next.prev = p;
            this.size--;
        }
    }
}
class DListNode{
    int val;
    DListNode next, prev;
    public DListNode(){}
    public DListNode(int val){
        this.val = val;
        this.next = null;
        this.prev = null;
    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

三、力扣206反转链表

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 reverseList(ListNode head) {
        ListNode newHead = new ListNode(0,null);
        while(head != null){
            ListNode p = head;
            head = head.next;
            p.next = newHead.next;
            newHead.next = p;
        }
        return newHead.next;
    }
}

2.双指针法反转单链表

/**
 * 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 temp = null;
        while(cur!=null){
            temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
}

2.递归反转单链表

/**
 * 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) {
        return reverse(null, head);
    }
    public ListNode reverse(ListNode prev, ListNode cur){
        if(cur==null){
            return prev;
        }
        ListNode temp = null;
        temp = cur.next;
        cur.next = prev;
        return reverse(cur, temp);
    }
}

总结

加上一个虚拟头结点方便操作

代码随想录Day46 647. 回文子串，516.最长回文子序列，动态规划最强总结篇！
get_money_的博客
12-27 881
代码随想录Day46 647. 回文子串，516.最长回文子序列，动态规划最强总结篇！
代码随想录day03之哈希表
2301_79918816的博客
08-04 2484
力扣242.有效的字母异位词、力扣349.两个数组的交集、力扣202.快乐数、力扣1.两数之和、力扣454.四数相加||、力扣383.赎金信、力扣15.三数之和、力扣18.四数之和 ​
代码随想录一刷总结
weixin_48013375的博客
08-22 457
代码随想录的题目安排和讲解都属于是很清晰简洁的，最好的一点在于是图文讲解配合视频，这样我不用每次都戴耳机去看课，只有不懂的才需要看课程而且也让我养成了写博客的习惯，边输入边输出，能进一步检查自己是不是理解了，比如后面图论的几章，确实是不怎么看得懂，所以就写的很少了，二刷的时候也能够根据这些来分辨自己哪里薄弱行百里者半九十，学吧学吧。
代码随想录二刷Day58
weixin_43908951的博客
11-04 384
删除操作和之前题目一样就不多说了；对一个字符串的增加操作就相当于给另一个字符串做删除操作，所以不需要考虑增的操作，只需要考虑删除就可以了。然后更改操作的目的是把最后一个数给改了然后就是dp[i-1][j-1] +1这个是变数， dp[i - 1][j], dp[i][j - 1]是两种删除。知道了递推公式挺好写的，和之前那道题差不多。
代码随想录系统性一刷总结
qq_44072579的博客
04-21 963
指针思想很重要day01 二分查找+移除元素day02 数组平方+长度最小子数组+螺旋矩阵II。
代码随想录一刷Day7 二叉树
qq_53306533的博客
11-28 1033
在Java中，封装类Integer是为了将int这种基本数据类型转换为对象，使其具有对象的特性，例如可以存放在集合类中，也可以为其提供一些额外的方法。
代码随想录一刷Day3
qq_53306533的博客
08-26 244
垃圾回收器使用的算法和策略因Java虚拟机的不同实现而异，常见的垃圾回收算法包括标记-清除算法（Mark and Sweep）、复制算法（Copying）、标记-整理算法（Mark and Compact）等。因此，当你删除链表节点时，你只需要确保没有直接或间接的引用指向这个节点，然后让垃圾回收器自动负责回收不可达的节点和释放相关的内存空间。在Java中，当删除链表节点时，内存回收是通过垃圾回收器（Garbage Collector）来处理的，而不是特定于删除节点的回收机制。先学习有关链表的储存知识。
代码随想录一刷day04
ResNet156的博客
05-27 289
链表的循环要找准结束条件和最小循环结构，先分析清楚往往事半功倍提示：以下是本篇文章正文内容，下面案例可供参考反复练习，可以更加熟练的掌握。
代码随想录一刷day02
ResNet156的博客
05-25 328
提示：每一天要有固定的流程，别浪费时间今天有点磨叽，明天要节约时间。
代码随想录一刷day57
ResNet156的博客
07-22 227
i >= 0;j ++) {// 情况一 和 情况二 result ++;//情况三 result ++;} }
代码随想录一刷day45
ResNet156的博客
07-15 203
1 , 2 };i <= n;j ++) {} }
代码随想录day11
cookieeee_的博客
07-30 233
239. 滑动窗口最大值（待解决）第五章 栈与队列part02150. 逆波兰表达式求值239. 滑动窗口最大值 （有点难度，可能代码写不出来，但一刷至少需要理解思路347.前 K 个高频元素 （有点难度，可能代码写不出来，一刷至少需要理解思路）150. 逆波兰表达式求值--后缀表达式思路中缀表达式：(1+2)*(3+4)后缀表达式：12+34+*遇到数字加入栈中，遇到符号就计算栈顶前两个元素栈适合做相邻字符的消除操作(符号匹配消除、或符号符合某种条件)
代码随想录-035期-算法训练营【博客笔记汇总表】
upward
04-10 1027
代码随想录-035期-算法训练营【博客笔记汇总表】
代码随想录-算法训练营day01【数组01：二分查找、移除元素、插入元素】
upward
04-04 753
代码随想录-算法训练营day01【数组01：二分查找、移除元素、插入元素】
力扣hot100：搜索二维矩阵
一本大学生java学习技术分享与交流
12-14 344
二分查找返回的是目标值最先出现的位置或者是在有序数组中的插入位置，如果是在有序数组中的插入位置则可能为在数组最后一个位置加一个数，这是如果进行matrix[i][weizi]==target的判断的话会导致数组越界，必须先处理越界问题，最终判断条件应为weizi<matrix[i].length&&matrix[i][weizi]==target。本题的本质是一个查找算法，为了提高性能可以使用二分查找，这个二维矩阵可以看出许多个数组，只需要对每个数组都进行一次二分查找就可以实现查找整个二维矩阵。
(leetcode) 力扣100 15轮转数组（环状替代）
最新发布
qq_62235017的博客
12-18 573
我们利用这个过程，首先计算需要多少个从起点走回起点的圈数（count，为数组长度与步数的最大公约数，具体推推导后面会给），然后再遍历每一圈，通过创建一个临时变量（current,next，类似于指针的作用），来存储需要移动的变量将其移动到下一个位置，而下一个位置变为信的需移动变量，直到走完当前圈数。我们可以把数组想象一个圆圈，如果我们每次固定步数前进，肯定会在有限圈数回到出发点，这个过程中，有可能会遍历完数组所有数，有可能遍历有限数。这句话的意思是：在这个游戏中，你启动一次任务，只能覆盖到。
leetcode：环形链表
thompson的博客
12-18 75
【代码】leetcode：环形链表。
LeetCode热题100--45. 跳跃游戏 II--中等
2301_80071187的博客
12-17 168
该问题要求在给定数组中，从起点出发，每次可跳跃最多nums[i]步，求到达终点的最小跳跃次数。解法采用贪心算法，维护当前可到达的最远位置(curRight)和下一步能到达的最远位置(nextRight)。遍历数组时不断更新nextRight，当到达curRight时进行跳跃并更新curRight为nextRight，同时增加跳跃次数。这种方法确保每次跳跃都选择能到达的最远位置，从而获得最小跳跃次数。时间复杂度O(n)，空间复杂度O(1)。示例输入[2,3,1,1,4]输出2，即从索引0跳1步到1，再跳3步到
Leetcode 79 最佳观光组合
im_AMBER的博客
12-17 454
每个元素只遍历一次只用了两个变量O(n)O(1)公式拆分是核心：将原得分公式拆分为，把双变量问题转化为单变量的遍历问题。贪心维护最优值：遍历j时，用best维护之前所有i < j中的最大值，这样每一步只需要 O (1) 计算，整体时间复杂度是 O (n)。遍历顺序：因为要求i < j，所以从j=1开始遍历，先计算当前j的得分，再更新best（避免 j 自己和自己配对）。
评论 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、付费专栏及课程。

余额充值