算法训练营Day3|链表part01

最新推荐文章于 2024-10-11 16:33:59 发布
最新推荐文章于 2024-10-11 16:33:59 发布
阅读量79 收藏
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45898193/article/details/133807576
版权
文章讲述了如何在Java中移除链表中的特定元素，使用虚拟头节点简化操作；介绍了MyLinkedList类的实现，包括get、add、delete和addAtIndex方法，以及链表反转的迭代和递归实现。
摘要由CSDN通过智能技术生成

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 dummyHead = new ListNode(0,head);
        ListNode pre = dummyHead;
        ListNode cur = dummyHead.next;
        while(cur!=null){
            if(cur.val==val){
                // 移除的元素pre不变，cur变
                pre.next = cur.next;
            }else{
                // 未移除的话都变
                pre = pre.next;
            }
            cur = cur.next;
        }
        return dummyHead.next;
    }
}
    • 收获
      • 方法：添加虚拟头节点。俩指针来操控当前node与之前node。要移除的就pre指向cur.next;这时只移动cur，pre不变
  • 题解心得
    • 使用方法一样，皆为头节点。但其添加了一个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 removeElements(ListNode head, int val) {
        if(head==null){
            return head;
        }
        ListNode dummyHead = new ListNode(0,head);
        ListNode pre = dummyHead;
        ListNode cur = dummyHead.next;
        while(cur!=null){
            if(cur.val==val){
                // 移除的元素pre不变，cur变
                pre.next = cur.next;
            }else{
                // 未移除的话都变
                pre = pre.next;
            }
            cur = cur.next;
        }
        return dummyHead.next;
    }
}

707.设计链表

  • 自我尝试
    • 代码 
      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 MyLinkedList {
    ListNode head;
    int size;

    public MyLinkedList() {
        this.head = new ListNode(-1);
        this.size = 0;
    }
    
    public int get(int index) {
        if(index>=size){
            return -1;
        }
        ListNode 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) {
        ListNode cur = head;
        while(cur.next!=null){
            cur = cur.next;
        }
        cur.next = new ListNode(val);
        this.size++;
    }
    
    public void addAtIndex(int index, int val) {
        if(index==this.size){
            addAtTail(val);
        }else if(index>this.size){
            //Invalid operation
            return;
        }else{
            //插入
            ListNode pre=this.head;
            ListNode cur=this.head.next;
            for(int i=0;i<index;i++){
                pre=cur;
                cur=cur.next;
            }
            pre.next = new ListNode(val);
            pre.next.next = cur;
            this.size++;
        }
    }
    
    public void deleteAtIndex(int index) {
        if(index>=this.size){
            // Invalid operation
            return;
        }
        ListNode pre=this.head;
        for(int i=0;i<index;i++){
            pre=pre.next;
        }
        pre.next=pre.next.next;
        this.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);
 */

    • 收获
      • 使用dummyhead提供遍历的便捷性
      • 引入size属性，在方法的实现中提供便利
  • 题解心得
    • 代码 
      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 MyLinkedList {
    ListNode head;
    int size;

    public MyLinkedList() {
        this.head = new ListNode(-1);
        this.size = 0;
    }
    
    public int get(int index) {
        // 小于0的index也考虑；
        if(index<0 ||index>=size){
            return -1;
        }
        ListNode 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) {
        //直接也使用addAtIndedx
        addAtIndex(this.size,val);
    }
    
    public void addAtIndex(int index, int val) {
         if(index>this.size){
            //Invalid operation
            return;
        }else{
            //可以只使用单个指针
            ListNode pre=this.head;
            for(int i=0;i<index;i++){
                pre=pre.next;
            }
            pre.next = new ListNode(val,pre.next);
            this.size++;
        }
    }
    
    public void deleteAtIndex(int index) {
        if(index>=this.size){
            // Invalid operation
            return;
        }
        ListNode pre=this.head;
        for(int i=0;i<index;i++){
            pre=pre.next;
        }
        pre.next=pre.next.next;
        this.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);
 */

    • 收获

      • addAtIndex方法里可以也通过一个指针直接进行操作。没必要两个。

206.反转链表

  • 自我尝试
    • 代码使用迭代法，通过三个pointer操作 
      /**
 * 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) {
        if(head==null){
            return null;
        }
        ListNode tmp;
        ListNode cur=head;
        ListNode pre=null;
        while(cur!=null){
            tmp = cur.next;
            cur.next = pre;
            pre=cur;
            cur = tmp;
        }
        return pre;

    }
}

  • 题解心得
    • 递归法比较难。递进到最底层，确定了新head后，层层传出来！同时在这个过程中进行链接的reverse 
      /**
 * 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) {
        // 边缘条件,传入为null
        if(head==null){
            return null;
        }
        // 边缘条件，确定最后一个node，并且返回
        if (head.next==null) return head;
        // 将head层层传递出来通过last
        ListNode last = reverseList(head.next);
        //反转
        head.next.next = head;
        //head指为空
        head.next = null;
        System.out.println(last.val);
        return last;
    }
}

Arteter
关注
代码随想录算法训练营Day3 | 链表part01
EE_Bee的博客
12-29 501
一刷状态：解出。
算法训练营 day4 ｜ 链表 part2
m0_68293482的博客
07-08 367
总结：本题依然要用到虚拟头节点。使用temp1和temp2把第一次交换的第二个节点和第二次交换的第二个节点保存下来。防止断链。需要注意的是，循环的判断条件。每次处理cur后面的两个节点。当节点总数量为偶数时，cur指针会被更新到最后一个节点，此时如果下个节点为空，则停止循环，奇数时cur指向倒数第二个节点。还要注意的是必须先判断cur.next然后再判断cur.next.next，反过来的话发生指针异常。
代码随想录算法训练营Day4 | 链表part02
EE_Bee的博客
12-30 438
一刷状态：通过。
代码随想录算法训练营Day03 | 链表part01
xinghemubai的博客
02-27 484
（空指针的意思）。数组是在内存中是连续分布的，链表在内存中不是连续分布的。而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。在面试的时候，往往要求先手写出来链表类的定义。
代码随想录算法训练营Day 03|链表Part01|203.移除链表元素 707.设计链表 206.反转链表
m0_51759998的博客
03-24 455
掌握一下虚拟头节点的用法，注意删除操作是要找到需删除节点的上一个节点，所以cur指向dummyhead，cur.next才能指向头节点，头节点才能被删除。本题需要搞清楚各个边界条件，以及增删get等操作的先后顺序。本题入手还是从双指针开始，递归的写法还需要再写几遍。
算法训练营Day4| 链表Part2
weixin_45898193的博客
10-15 115
19.删除链表的倒数第N个节点。面试题 02.07. 链表相交。142.环形链表II。
代码随想录算法训练营day4|链表 part2
Lv2_x的博客
05-11 463
链表做题总结
代码随想录算法训练营Day4|链表part2
weixin_57654532的博客
08-26 146
这里不是从头开始判断是否有相同的，而是先将尾部对齐。其实并不是很难，但是递归的还是很难😭😭😭😭😭。应该可以用hash表来做，but是链表的章节。重要的是Z的大小，决定了入口处。代码随想录里面有详细的图解。递归版（来自代码随想录）
代码随想录训练营day3|链表part1
weixin_45831563的博客
07-07 199
【代码】代码随想录训练营day3|链表part1。
算法训练营第二天1
08-03
"算法训练营第二天1" 本节课程主要讲解了算法训练营第二天的内容，涵盖了查找、排序、哈希表、Trie、LRU Cache 等多种数据结构和算法思想。 首先，课程讲解了二分查找（Binary Search）算法的实现细节，包括如何...
leetcode求链表中点-AlgoBootcamp:算法训练营
07-06
leetcode求链表中点 数据结构 | 算法 | 力扣笔记 数据结构 队列：FIFO - 可以使用节点（更高效）或数组及其方法（push pop 等）构建 堆栈：LIFO - 可以使用节点（更有效）或数组及其方法（push pop 等）构建 对于...
进击极限算法训练营 60G最新大厂算法实战 互联网大厂大牛讲师带你提炼 内功心法
08-29
### 进击极限算法训练营概述 #### 开学典礼视频 1. **笙南：《为什么我会参加两次算法训练营？》** - 讲师介绍自己多次参与算法训练营的经历，并分享其中的原因，可能包括个人技能提升的需求、对算法深度理解的...
代码随想录算法训练营day4
weixin_44520607的博客
11-23 574
代码随想录算法训练营day4
【数据结构】双向链表（Doubly Linked List）
2301_77727857的博客
10-05 587
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
常见排序算法汇总
weixin_44238730的博客
10-05 609
常见排序算法汇总，C++实现
数据结构之图（6）
2301_76246515的博客
10-05 999
图G有顶点集V和边集E组成，记为G=(V,E),其中V（G）表示图G中顶点的有限非空集；E(G)表示图G中顶点之间的关系（边）集合。若V={v1,v2,…，vn}，则用|V|表示图G中顶点的个数。也称为图G的阶E={（u,v)|u ∈​​​V},用|E|表示图G中边的条数图不可以是空，V一定是非空集E是无向边（简称边）的有限集合E是有向边（弧）的有限集合弧是顶点的有序对，记为<v,w>,v为弧尾，w为弧头不存在重复边不存在顶点到自身的边。
C语言 动态数据结构的C语言实现内存映像
hangweijie的博客
10-04 423
在程序运行期间，用动态内存分配函数来申请的内 存都是从堆上分配的，动态内存的生存期由程序员 自己来决定。在执行函数调用时，系统在栈上为函数内的局部变 量及形参分配内存，函数执行结束时，自动释放这 些内存。在执行函数调用时，系统在栈上为函数内的局部变 量及形参分配内存，函数执行结束时，自释放这 些内存。存放函数参数值，局部变量值等。存放函数参数值，局部变量值等。C程序中变量的内存分配方式。C程序中变量的内存分配方式。C程序中变量的内存分配方式。C程序中变量的内存分配方式。
浙大数据结构：08-图9 关键活动
最新发布
qq_74924951的博客
10-11 255
拓扑排序找关键活动
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值