Day3| 203.移除链表元素，707.设计链表，206.反转链表

已于 2023-09-23 21:45:17 修改
阅读量79 收藏
点赞数
文章标签： leetcode java
于 2023-09-23 11:39:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75037696/article/details/133183541
版权

203.移除链表元素代码随想录

/**
 * 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 dh = head , p = dh;//dh初始化时没有接上链表
        while(p != null){//出现空指针异常，说明操作了某些空指针，要么越界要么对同一对象使用了多个指针
            if(p.next.val == val){
                p.next = p.next.next;
            }else{
                p = p.next;
            }
        }
        return dh.next;
    }
}

//修改后代码
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dh = new ListNode();
        dh.next = head;
        ListNode p = dh;
        while(p.next != null){
            if(p.next.val == val){
                p.next = p.next.next;
            }else{
                p = p.next;
            }
        }
        return dh.next;
    }
}

 707.设计链表代码随想录

一、想一下目标位置是由哪一个位置变化而来，假如目标位置是最后一个节点，由倒数第二个节点前进得来，那么这个过程就应当是最后一次循环的语句，其执行条件即是最后一次执行条件，其下一个过程的执行条件即是终止条件，一般取终止条件的否定，感觉这些条件判断要多见识积累。

二、应用于get节点和增删节点寻找其前一个节点的过程

 出错程序一：

class Node {
    int val;
    Node next;
    Node(){}
    Node(int val) {
        this.val=val;
    }
}
class MyLinkedList {
    int size;
    Node head;

    public MyLinkedList() {
        size = 0;
        head = new Node(0);
    }
 
    
    public int get(int index) {
        if(index < 0 || index >= size){
            return -1;
        }
        Node p = head;
        while(index != 0){
            p = p.next;
            index--;
        }
        return p.val;
        
    }
    
    public void addAtHead(int val) {
        // Node dummy = new Node();
        // Node x = new Node(val);
        // x.next = dummy.next;
        // dummy.next = x;
        addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        // Node x = new Node(val);
        // Node p = head;
        // while(p.next != null){
        //     p = p.next;
        // }
        // p.next = x;
        addAtIndex(size,val);
    }
    
    // public void addAtIndex(int index, int val) {
    //     if(index > size){
    //         return;
    //     }
    //     if(index == 0){
    //         index = 0;
    //     }
    //     Node dummy = new Node();
    //     dummy.next = head;
    //     Node p = dummy;
    //     //while(index != 0)
    //     for(int i = 0; i < index; i++){
    //         p = p.next; 
    //     }
    //         Node x = new Node(val);
    //         x.next = p.next;
    //         p.next = x;
    //         size++;
        
        
    // }
    public void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        if (index < 0) {
            index = 0;
        }
        size++;
        //找到要插入节点的前驱
        Node dummy = new Node();
        dummy.next = head;
        Node pred = dummy;
        for (int i = 0; i < index; i++) {
            pred = pred.next;
        }
        Node toAdd = new Node(val);
        toAdd.next = pred.next;
        pred.next = toAdd;
    }
    
    public void deleteAtIndex(int index) {
        if(index < 0 || index >= size){
            return;
        }
        Node dummy = new Node();
        dummy.next = head;
        Node p = dummy;
        while(index != 0){
            p = p.next;
            index--;
        }
        p.next = p.next.next;


    }
    // public int getsize(){
    //     Node p = head;
    //     int count = 0;
    //     while(p != null){
    //         count++;
    //         p = p.next;
    //     }
    //     return count;
    // }
 
    // public boolean isIndexValid(index){
    //     int size = getsize();
    //     if(index >= 0 && index < size - 1){
    //         return true;
    //     }else{
    //         return true;
    //         }
        
    // }
}

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

出错程序二： 

class Node {
    int val;
    Node next;
    Node(){}
    Node(int val) {
        this.val=val;
    }
}
class MyLinkedList {
    int size;
    Node head;
    public MyLinkedList() {
        size = 0;
    }
    
    public int get(int index) {
        if(index < 0 || index >= size){
            return -1;
        }
        Node p = head;
        while(index != 0){
            p = p.next;
            index--;
        }
        return p.val;

    }
    
    public void addAtHead(int val) {
        addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        addAtIndex(size,val);
    }

    public void addAtIndex(int index, int val) {
        if(index > size){
            return;
        }
        if(index < 0){
            index = 0;
        }
        Node dummy = new Node();
        dummy.next = head;
        Node p = dummy;
        while(index != 0){
            p = p.next; 
            index--;
        }
            Node x = new Node(val);
            x.next = p.next;
            p.next = x;
            size++;
    }

    public void deleteAtIndex(int index) {
        if(index < 0 || index >= size){
            return;
        }
        Node dummy = new Node();
        dummy.next = head;
        Node p = dummy;
        while(index != 0){
            p = p.next;
            index--;
        }
        p.next = p.next.next;
    }

}

没出错 

class Node {
    int val;
    Node next;
    Node(){}
    Node(int val) {
        this.val=val;
    }
}
class MyLinkedList {
    int size;
    Node dummyhead;
    public MyLinkedList() {
        size = 0;
        dummyhead = new Node(0);
    }
    
    public int get(int index) {
        if(index < 0 || index >= size){
            return -1;
        }
        Node p = dummyhead;
        while((index+1) != 0){
            p = p.next;
            index--;
        }
        return p.val;

    }
    
    public void addAtHead(int val) {
        addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        addAtIndex(size,val);
    }

    public void addAtIndex(int index, int val) {
        if(index > size){
            return;
        }
        if(index < 0){
            index = 0;
        }
        size++;
        Node p = dummyhead;
        for(int i = 0; i<index;i++){
            p = p.next; 
            
        }
            Node x = new Node(val);
            x.next = p.next;
            p.next = x;
            
    }

    public void deleteAtIndex(int index) {
        if(index < 0 || index >= size){
            return;
        }
        
        Node p = dummyhead;
        while(index != 0){
            p = p.next;
            index--;
        }
        p.next = p.next.next;
        size--;
    }

}

出错程序三：

class Node {
    int val;
    Node next;
    Node(){}
    Node(int val) {
        this.val=val;
    }
}
class MyLinkedList {
    int size;
    Node dummyhead;
    public MyLinkedList() {
        size = 0;
        dummyhead = new Node(0);
    }
    
    public int get(int index) {
        if(index < 0 || index >= size){
            return -1;
        }
        Node p = dummyhead;
        while((index+1) != 0){
            p = p.next;
            index--;
        }
        return p.val;

    }
    
    public void addAtHead(int val) {
        addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        addAtIndex(size,val);
    }

    public void addAtIndex(int index, int val) {
        if(index > size){
            return;
        }
        if(index < 0){
            index = 0;
        }
        size++;
        Node p = dummyhead;
        for(int i = 0; i<index;i++){
            p = p.next; 
            
        }
            Node x = new Node(val);
            x.next = p.next;
            p.next = x;
            
    }

    public void deleteAtIndex(int index) {
        if(index < 0 || index >= size){
            return;
        }
        
        Node p = dummyhead;
        while(index != 0){
            p = p.next;
            index--;
        }
        p.next = p.next.next;
        size--;
    }

}

没出错 

class Node {
    int val;
    Node next;
    Node(){}
    Node(int val) {
        this.val=val;
    }
}
class MyLinkedList {
    int size;
    Node dummyhead;
    public MyLinkedList() {
        size = 0;
        dummyhead = new Node(0);
    }
    
    public int get(int index) {
        if(index < 0 || index >= size){
            return -1;
        }
        Node p = dummyhead;
        while((index+1) != 0){
            p = p.next;
            index--;
        }
        return p.val;

    }
    
    public void addAtHead(int val) {
        addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        addAtIndex(size,val);
    }

    public void addAtIndex(int index, int val) {
        if(index > size){
            return;
        }
        if(index < 0){
            index = 0;
        }
        size++;
        Node p = dummyhead;
        for(int i = 0; i<index;i++){
            p = p.next; 
            
        }
            Node x = new Node(val);
            x.next = p.next;
            p.next = x;
            
    }

    public void deleteAtIndex(int index) {
        if(index < 0 || index >= size){
            return;
        }
        
        Node p = dummyhead;
        while(index != 0){
            p = p.next;
            index--;
        }
        p.next = p.next.next;
        size--;
    }

}

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

我很执着于用head放入链表，在函数中添加dummy再操作，力扣判题时是直接在dummyhead后加新元素

head不算是第0个节点wc。head本身就是虚拟头结点，哨兵节点

size更新非常重要，会决定index约不越界，若删除了节点没更新size--，下一次删除index即使越界自己的判定语句也不会抛异常，而是执行while循环导致p越界去操作空指针。

总结，之前很多次提交没过

原因一：0号节点是从head.next开始的，

原因二：size没更新，导致index异常时还会走while循环，导致p越界操作了空指针。

检查时，重心都放在p有没有走到正确的位置上的代码逻辑有误问题，这个过程自己默认传入while的index值是合法的，实际上size的没更新，造成了越界，耗费了很多时间。一开始我的p从head前一个dummy开始走，理论上，到达的位置更靠前，也出现了p越界，现在想来原因大概还是出现在没有size--，以致index越界没被检测出来进入了while。

最后修改版本：

class Node {
    int val;
    Node next;
    Node(){}
    Node(int val) {
        this.val=val;
    }
}
class MyLinkedList {
    int size;
    Node head;

    public MyLinkedList() {
        size = 0;
        head = new Node(0);
    }
 
    
    public int get(int index) {
        if(index < 0 || index >= size){
            return -1;
        }
        Node p = head.next;
        while(index != 0){
            p = p.next;
            index--;
        }
        return p.val;
        
    }
    
    public void addAtHead(int val) {
        Node x = new Node(val);
        x.next = head.next;
        head.next = x;
        size++;
        //addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        Node x = new Node(val);
        Node p = head;
        while(p.next != null){
            p = p.next;
        }
        p.next = x;
        size++;
        //addAtIndex(size,val);
    }
    
    public void addAtIndex(int index, int val) {
        if(index > size){
            return;
        }
        if(index < 0){
            index = 0;
        }
        
        Node p = head;
        while(index != 0){
            p = p.next; 
            index--;//漏了，死循环，p越界空指针了，重心都放在走了多少步，却忘了更新index
        }
            Node x = new Node(val);
            x.next = p.next;
            p.next = x;
            size++;
        
        
    }

    
    public void deleteAtIndex(int index) {
        if(index < 0 || index >= size){
            return;
        }
        
        Node p = head;
        while(index != 0){
            p = p.next;
            index--;
        }
        p.next = p.next.next;
        size--;//漏了，导致第二次删节点时即使index越界了也能进入循环使p操作了空指针
    }

}

 206.反转链表代码随想录

双指针：

/**
 * 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 p = head , p0 = null;
        while(p != null){
        ListNode temp = new ListNode();
        temp = p.next;
        p.next = p0;
        p0 = p;
        p = temp;//对应关系: p每一次前进都对应一次反转操作，最后一次情形：p在tail处反转tail后并前进到null,终止状态是p == tail时执行，p == null不执行
        }
        return p0;//直接把反转后的第一个节点当成头节点就好，虽然其有值，但题目要求就是单纯反转操作，不能在原链表上再接一个无值的head
    }
}

递归：

 递归太抽象了，脑子转不过来，有空再看，

感觉跟循环有对应的地方，有正着迭代下去的操作，一层一层套进去，这题的循环也是正着迭代下去的，暂且先掌握双指针做法。

双指针还能画个链表图比划比划较快地写出来，递归先留着。

m0_75037696
关注
day3 | 203.移除链表元素 707.设计链表 206.反转链表
m0_52746639的博客
12-30 227
leetcode
Day 3 | 203.移除链表元素 707.设计链表 206.反转链表
weixin_54143009的博客
01-12 835
首先是创建ListNode时候，需要new一个。第二个，刚开始我弄混了 cur->next 和 tmp，我错以为是这俩个指针同时指向要被删除的值 val，但是细想一下，在最开始，我先用tmp指向了被删除的链表，接着用 cur->next 指向了下一个删除后的链表，所以 cur->next 已经跟要被删除的链表无关了，所以只有 tmp 指向要删除列表，则只需要 delete tmp 即可做到释放要被删除的链表元素。一个就是头指针，我们用虚拟头指针来代替，另一个就是链表长度。
代码随想录算法训练营Day3 | 203.移除链表元素 707.设计链表 206.反转链表
qq_24817679的博客
04-08 1712
2. 删除head时候 tmp=head，删除cur->next，tmp=cur->next.1.需判断cur以及cur->next是否为空。
代码随想录day3 | 203.移除链表元素 707.设计链表 206.反转链表
想要上进的coder的博客
07-15 1344
反转链表 设计链表 双指针+递归写法
代码随想录C++ Day3 | 203.移除链表元素 707.设计链表 206.反转链表
blackdog_的博客
06-25 735
cur指针负责遍历链表，将遍历到的节点的next赋值为前一个节点，也就是pre指针指向的节点。由于cur的next的指向已经被修改了，遍历无法继续，于是还需要一个temp指针，提前保存cur->next的值（纠正：动画应该是先移动pre，在移动cur）直观来说，重新创建一个空链表，然后再将原链表的每个节点依次插入到新建链表的头节点，时间和空间复杂度都是O(n)// 链表变为 1->2->3。// 现在，链表变为 1->3。，请你反转链表，并返回反转后的链表。是指向下一个节点的指针/引用。
day03| 203.移除链表元素 707.设计链表 206.反转链表
m0_65709641的博客
07-05 869
1、注意while与if的顺序2、注意while(head!=null&&head.val == val)与if(head==null)顺序不可变，万一为【7,7,7,7,7】，head节点就变成了null，无法执行之后的代码// 定义单链表int val;// 链表中元素的个数int size;size = 0;return -1;// 包含一个虚拟头结点i<=index;return;
Day03 | 203.移除链表元素 707.设计链表 206.反转链表
q864508127的博客
07-05 694
第五个类void addAtIndex(int index, int val)先定义值为val的新节点，判断index的长度，如果是0放在头节点，遍历到index的前一个节点进行插入。第三个类void addAtHead(int val) 插入一个元素之前，虚拟头节点派上用处了，定义一个新的节点，然虚拟头节点的next指向新节点。第四个类void addAtTail(int val) 追加最后一个节点，遍历到最后一个节点，定义一个新节点，让最后一个节点的next等于新节点。如果下标无效，则返回 -1。
代码随想录算法训练营 DAY3| 203.移除链表元素 707.设计链表 206.反转链表
qq_35904005的博客
03-09 968
记得要写构造函数。// 结点的值int val;// 下一个结点// 节点的构造函数(无参)// 节点的构造函数(有一个参数)// 节点的构造函数(有两个参数)遍历条件里最好不要写cur->next。当cur为null时会空指针异常遍历链表找结束条件就是看 到什么情况下，就停止操作了，找这个临界情况就是while里的判断条件递归需要考虑终止条件，下一次递归的新参数以及返回值。通常另外写一个函数用来递归，在原函数里调用它。
Day3|203.移除链表元素|707.设计链表|206.反转链表
m0_51395560的博客
09-16 217
【代码】Day3|203.移除链表元素|707.设计链表|206.反转链表。
代码随想录Day3| 203.移除链表元素707.设计链表206.反转链表
sRiddle的博客
12-29 746
Day3
【代码随想录刷题笔记】DAY3 203.移除链表元素 707.设计链表 206.反转链表
Azimumiao的博客
11-18 681
【代码随想录刷题笔记】DAY3 203.移除链表元素 707.设计链表 206.反转链表
代码随想录算法训练营Day3 | 链表理论基础，203.移除链表元素，707.设计链表，206.反转链表
little__penguin的博客
06-08 393
代码随想录算法训练营Day03:203.移除链表元素，707.设计链表，206.反转链表
weixin_57956443的博客
12-09 148
代码随想录算法训练营Day03:203.移除链表元素，707.设计链表，206.反转链表
DAY3:链表（一）：链表基础知识+移除链表元素
CFY1226的博客
05-13 2545
/ 单链表的定义 struct ListNode {int val;//节点上储存的元素 ListNode * next;//指向下一个节点的指针 ListNode(int x) : val(x) , next(NULL) {//节点的构造函数 } }//定义指针，指向链表对象（虚拟头节点用法）所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！首先，你需要一个指针来找到要删除的节点。这个指针通常是通过遍历链表得到的。
代码随想录day3链表1
qq983730061的博客
01-09 469
链表是一种由指针串联在一起的线性结构，每个被串联起来的节点有指针域与数据域，指针域存放下个节点的指针，最后一个节点的指针域指向null。
LeetCode[中等] 739. 每日温度
最新发布
Theolulu的博客
09-30 221
给定一个整数数组，表示每天的温度，返回一个数组answer，其中answer[i]是指对于第i天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用0来代替。
LeetCode 面试经典150题 66.加一
qq_57349657的博客
09-27 266
加一
Java - LeetCode面试经典150题(二)
心如冰清，天塌不惊
09-28 784
否则，返回 false。给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。遍历字符串数组，将其中的字符串，进行排序，这样就形成一个唯一的字符串了，之后将原字符串追加到这个排序完的字符串映射的String列表中。这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。将magazine中的每个字符的个数记录下来，用map映射成。
LeetCode 69. x 的平方根
野草说技术
09-27 358
注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5。解释：8 的算术平方根是 2.82842…, 由于返回类型是整数，小数部分将被舍去。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去。给你一个非负整数 x ，计算并返回 x 的 算术平方根。
LeetCode链表算法刷题笔记：移除元素、设计链表、反转链表
设计链表和206.反转链表。主要讨论了解题思路和Java语言的解决方案。 ### 203. 移除链表元素 这道题目要求从链表中删除所有值等于`val`的节点。解题的关键在于处理可能的头节点删除情况。通过在链表的头节点前添加...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值