随想录刷题笔记 —链表篇1 203移除链表元素 707设计链表 206反转链表

已于 2024-01-26 23:08:07 修改
阅读量283 收藏 9
点赞数 10
分类专栏： 随想录刷题 文章标签： 笔记 链表 数据结构 java
于 2024-01-26 23:03:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44936793/article/details/135874540
版权

203移除链表元素

删除链表中所有值为val的节点

我的题解：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode left = head;
        while (left!=null&&left.val==val){
            left = left.next;
        }
        ListNode newhead = left;
        if (newhead==null){
            return newhead;
        }
        ListNode right = left.next;
        while (right!=null){
            if (right.val==val) {
                left.next = right.next;
            }else {
                left = left.next;
            }
            right = right.next;
        }
        return newhead;
    }
}

查找值非val的第一个结点设为头结点，使用前后结点指针，用于删除值为val的结点。

看了其他题解

新创建一个无值意义的头结点，用于标记头结点，这样就无需查找值非val的第一个结点了。

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head == null){
            return head;
        }

        ListNode virtualNode = new ListNode(-1, head);
        ListNode pre = virtualNode;
        ListNode cur = head;
        while(cur != null){
            if(cur.val == val){
                pre.next = cur.next; 
            } else {
                pre = cur;
            }
            cur = cur.next;
        }

        return virtualNode.next;
    }
}

707设计链表

设计链表 实现 按下标查找 从头尾插入元素 按下标插入元素 删除元素 等功能

我的题解：

class MyLinkedList {

    int val;
    MyLinkedList next;

    public MyLinkedList() {
    }
    public  MyLinkedList(int val, MyLinkedList next) { this.val = val; this.next = next; }

    public int get(int index) {
        MyLinkedList node = this.next;
        int num = 0;
        while (node!=null){
            if (num == index){
                return node.val;
            }
            num++;
            node = node.next;
        }
        return -1;
    }

    public void addAtHead(int val) {
        MyLinkedList headnode = new MyLinkedList(val, this.next);
        this.next = headnode;
    }

    public void addAtTail(int val) {
        MyLinkedList node = this;
        while (node.next!=null){
            node = node.next;
        }
        MyLinkedList tailnode = new MyLinkedList(val, node.next);
        node.next = tailnode;
    }

    public void addAtIndex(int index, int val) {
        MyLinkedList node = this;
        int num = -1;
        while (node!=null){
            if (num == index-1){
                MyLinkedList indexnode = new MyLinkedList(val, node.next);
                node.next = indexnode;
                break;
            }
            num++;
            node = node.next;
        }
    }

    public void deleteAtIndex(int index) {
        MyLinkedList prenode = this;
        MyLinkedList node = this.next;
        int num = 0;
        while (node!=null){
            if (num == index){
                prenode.next = node.next;
                break;
            }
            num++;
            prenode = prenode.next;
            node = node.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);
 */

用单链表直接就是从头往后找。。。暴力破解了属于

看了其他题解，

使用了另一个Node类作为结点具体内容的存储，List类只保存Node头结点的List容量大小，这样就可以直接判断下标是否合理，也可以直接按照尾部索引插入了

class LinkedNode {
    int val;
    LinkedNode next;
    LinkedNode(){}
    LinkedNode(int val) {
        this.val = val;
        this.next = null;
    }
}

class MyLinkedList {
    LinkedNode head;
    int size;

    public MyLinkedList() {
        head = new LinkedNode(0);
        size = 0;
    }
    
    public int get(int index) {
        if (index < 0 || index >= size){
            return -1;
        }
        LinkedNode cur = head;
        for (int i = 0; i <= index; i++) {
            cur = cur.next;
        }
        return cur.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 || index < 0) {
            return;
        }
        LinkedNode cur = head;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        LinkedNode toAdd = new LinkedNode(val);
        toAdd.next = cur.next;
        cur.next = toAdd;
        size++;
    }
    
    public void deleteAtIndex(int index) {
        if (index >= size || index < 0) {
            return;
        }
        size--;
        LinkedNode cur = head;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        cur.next = cur.next.next;
    }
}

双链表再和size结合，就可以看索引是离头结点近，还是尾结点近。

注意双链表，要创建头和尾两个哨兵结点。

class MyLinkedList {
    int size;
    ListNode head;
    ListNode tail;


    class ListNode{
        int val;
        ListNode prev;
        ListNode next;
        public ListNode(int val) {
            this.val = val;
        }
    }


    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);
        tail = new ListNode(0);
        head.next = tail;
        tail.prev = head;
    }
    
    public int get(int index) {
        if(index<0||index>=size){
            return -1;
        }
        ListNode cur;
        //比较从head还是tail哪个更快找到目标
        if(index+1<size-index){//head更快
           cur=head;
           for(int i=-1;i<index;i++){
               cur=cur.next;
           }
        }else{//tail更快
            cur=tail;
            for(int i=size;i>index;i--){
                cur=cur.prev;
            }
        }
        return cur.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;
        }
        index = Math.max(0, index);
        ListNode pred, succ;
        if(index<size-index){
            pred=head;
            for(int i=-1;i<index-1;i++){
                pred=pred.next;
            }
            succ=pred.next;
        }else{
            succ=tail;
            for(int i=size;i>index;i--){
                succ=succ.prev;
            }
            pred=succ.prev;
        }

        size++;
        ListNode add=new ListNode(val);
        add.prev=pred;
        add.next=succ;
        pred.next=add;
        succ.prev=add;
    }
    
    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        ListNode pred, succ;
        if (index < size - index) {
            pred = head;
            for (int i = 0; i < index; i++) {
                pred = pred.next;
            }
            succ = pred.next.next;
        } else {
            succ = tail;
            for (int i = size; i > index + 1; i--) {
                succ = succ.prev;
            }
            pred = succ.prev.prev;
        }
        size--;
        pred.next = succ;
        succ.prev = pred;
    
    }
}

206反转链表

返回反转后的链表

用循环解决：用3个指针解决，分别标志pre node next，然后node->pre pre变成node node变成next，直到尾

注意最后要把head的next置空

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head==null){
            return head;
        }
        ListNode prenode = head;
        ListNode node = head.next;
        while (node!=null){
            ListNode nextnode = node.next;
            node.next = prenode;
            prenode = node;
            node = nextnode;
        }
        head.next = null;
        return prenode;
    }
}

用递归解决

需要第二个函数用于递归，递归出口是到达尾结点，每个递归都返回next结点

在递归里，需要把返回的next结点的next改为此结点

注意最后要把head的next置空

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head==null||head.next==null){
            return head;
        }
        ListNode prenode = head;
        
        while (prenode.next!=null){
            prenode = prenode.next;
        }
        ListNode node = head;
        reverse(node);
        head.next = null;
        return prenode;
    }
    public ListNode reverse(ListNode head) {
        if (head.next==null){
            return head;
        }

        ListNode node = reverse(head.next);
        node.next = head;
        return head;
    }
}

收获

可以通过创建哨兵结点从而便于头结点处理

链表集合的概念，可以使用list类来存储头结点和大小

XWHQQ7426
关注
  • 10
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【代码随想录刷题笔记】DAY3 203.移除链表元素 707.设计链表 206.反转链表
Azimumiao的博客
11-18 606
【代码随想录刷题笔记】DAY3 203.移除链表元素 707.设计链表 206.反转链表
【Leetcode刷题笔记03】203.移除链表元素 707.设计链表 206. 反转链表.md
01-13
内容概要:本文包含三道LeetCode链表算法题的刷题笔记,分别是203.移除链表元素、707.设计链表和206.反转链表,记录了详细的题目解析思路以及Java语言的参考代码。 适合人群:学习算法和数据结构的程序员或学生,尤其是...
【代码随想录刷题笔记 Day 3】203、移除链表元素 | 707、设计链表 | 202、翻转链表
rzluo的博客
02-06 192
链表
代码随想录刷题笔记 DAY3 | 移除链表元素 No. 203 | 设计链表 No. 707 | 反转链表 No. 206
weixin_74895237的博客
12-29 1277
今日总结：虽然之前刷过链表，但这次做的是有些费力的，也有了更深的理解。整理完今天的 Vue 笔记就睡。。。
代码随想录笔记_链表_203移除链表元素
Erik_Ying的博客
07-18 156
链表，数据结构，力扣，算法
【代码随想录刷题笔记】【链表】2. 移除链表元素
tyut_lzy的博客
11-01 36
刷题笔记
代码随想录算法训练营第三天|203.移除链表元素 707.设计链表 206.反转链表
随便写写的博客
07-29 556
然后把p->next指向pre，p向后走，pre向后走，直到p指向空，说明所有的元素都处理了一遍，整个链表反转完成，pre指向的就是新的头节点。此外，需要注意的是，这里所说的头节点和考研中所学的头节点是两个概念，这里的头节点是指链表的第一个节点，对应于考研中不带头节点的链表，这里所插入的虚拟头节点对应于考研中的头节点，此外掌握c++语法，如何新建一个节点，使用关键字new 例如ListNode *head = new ListNode(头节点的值)//p=p->next;//两个指针向后移动。
代码随想录训练营day3 | 203. 移除链表元素,707.设计链表，206. 反转链表
weixin_46536635的博客
03-09 1752
203. 移除链表元素 文章链接：代码随想录 (programmercarl.com) 视频链接：代码随想录算法公开课 | 最强算法公开课 | 代码随想录 笔记 此处头结点并非书中头结点，所以需要构造一个伪头结点 不构造伪头结点的情况下，需要分成，对头结点和非头结点两种情况 C++代码 伪头结点 class Solution { public: ListNode* removeElements(ListNode* head, int val) { ListNod
代码随想录第三天|203.移除链表元素、 707.链表设计、206.反转链表
m0_56161981的博客
09-24 202
一、链表理论基础单链表双链表循环链表删除节点和增加节点就是改变一个节点的next指向新的节点即可（虚节点=头节点） .next = 首元节点二、删除链表元素第一遍写的错误代码-----错误的点 ： 1、while里面的循环是不能用if的2、写的时候不画图，盲目自信 少了对新结点为空的判断3. 虚结点的书写不正确4.最终要的是！！！要先存储再操作虚节点-------------其中有个最重要的。
Amber代码随想录打卡第三天｜203.移除链表元素、707.设计链表、206.反转链表
avery66666的博客
01-12 381
困难：较难学习 : 2h状态：待更新代码随想录。
《剑指Offer》刷题笔记——面试题24. 反转链表
01-20
1、leetcode解析 2、测试用例 3、代码实现 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None from collections import deque class Solution...
leetcod 203.移除链表元素：
08-24
题目描述 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。...解题思路有两种：（一）要移除...具体思路详解请看拿捏链表（一）---------移除链表元素
xiaoxfan#leetcode#203. 移除链表元素1
07-25
示例:输出: 1->2->3->4->5方法一递归func removeElements(head *ListNode, val int) *ListNode
bestlyg#bestlyg-leetcode#203.移除链表元素1
07-25
简介：删除链表中等于给定值val的所有节点。编辑时间：2020.2.13执行用时：1ms内存消耗：40.1MB编程语言：java解法介绍：创建新链表，遍历节点，
Python学习笔记11 -- 细碎内容
最新发布
m0_71291382的博客
06-12 234
记录一些琐碎点，包括如何注释、变量常量说明、字符串拼接的三种方法及转义字符的简单说明
《雅思口语真经总纲1.0》笔记——第二章：官方评分标准真经——Lexical Resource 词汇资源——三十组同义形容词列表
Dontla的博客
06-09 623
直接提取词汇重点，不看例句了。
Nginx学习笔记（十）如何配置HTTPS协议？（公网）
ACGkaka的博客
06-10 722
Nginx学习笔记（十）如何配置HTTPS协议？（公网）
802.11漫游流程简单解析与笔记_Part3
Mr_liu_666的博客
06-10 243
看过Part1的应该都知道，标准关联流程是auth*2 associate*2 key*4，但ns3里面没有与auth有关的部分，third脚本里面有cap字段，但无auth也无key，所以part3是空的
移除链表元素（python)
03-28
以下是移除链表元素的Python代码： ```python class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next def removeElements(head: ListNode, val: int) -> ListNode: # 处理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值