【Java数据结构】详解LinkedList与链表（三）

已于 2024-06-06 09:26:58 修改
阅读量459 收藏 13
点赞数 8
分类专栏： JAVA知识点专栏 文章标签： java 数据结构 开发语言
于 2024-06-02 12:49:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Easonmax/article/details/138842538
版权

🔒文章目录：

1.❤️❤️前言~🥳🎉🎉🎉

2.无头双向非循环链表的实现

2.1成员属性

2.2成员方法 

display——打印链表 

 size——获取单链表长度 

addFirst——头插 

 addLast——尾插 

addIndex——在任意位置插入 

 contains——判定是否包含某个元素 

remove——删除第一次出现关键字为key的结点 

 removeAll——删除所有值为key的结点  

clear——清空单链表  

2.3完整代码及使用

完整代码

完整代码的使用

3.总结

1.❤️❤️前言~🥳🎉🎉🎉

Hello, Hello~ 亲爱的朋友们👋👋，这里是E绵绵呀✍️✍️。

如果你喜欢这篇文章，请别吝啬你的点赞❤️❤️和收藏📖📖。如果你对我的内容感兴趣，记得关注我👀👀以便不错过每一篇精彩。

当然，如果在阅读中发现任何问题或疑问，我非常欢迎你在评论区留言指正🗨️🗨️。让我们共同努力，一起进步！

加油，一起CHIN UP！💪💪

🔗个人主页：E绵绵的博客
📚所属专栏：

1. JAVA知识点专栏

        深入探索JAVA的核心概念与技术细节

2.JAVA题目练习

        实战演练，巩固JAVA编程技能

3.c语言知识点专栏

        揭示c语言的底层逻辑与高级特性

4.c语言题目练习

        挑战自我，提升c语言编程能力

📘 持续更新中，敬请期待❤️❤️

2.无头双向非循环链表的实现

2.1成员属性

其成员属性跟无头单向非循环链表的成员属性类似。只是在内部类中多了个prev前驱，以及成员变量多了个last。

public class MyLinkedList {
    static class ListNode{
        int val;
        ListNode next;
        ListNode  prev;

        public ListNode(int val) {
            this.val = val;
        }
    }
        ListNode head;
        ListNode  last;

2.2成员方法 

display——打印链表 

 注意：MyLinkedList 中不存在该方法，为了方便看测试结果 。

public void display(){
            ListNode cur=head;
            if(head==null)
                return;
            while(cur!=null){
                System.out.print(cur.val+"  ");
                cur=cur.next;
            }
            System.out.println();
        }

 size——获取单链表长度 

   直接遍历链表即可

 public int size(){
            ListNode cur=head;
            int count=0;
            while(cur!=null){
               cur =cur.next;
               count++;
            }
            return  count;
           }

addFirst——头插 

实现思路：

  1. 判断链表是否为空，如果为空，直接将head和last指向新节点listNode。
  2. 如果链表不为空，将新节点listNode的next指向当前头节点head，当前头节点head的prev指向新节点listNode，最后将head指向新节点listNode，完成头插操作。
   public  void addFirst(int a){
            ListNode listNode = new ListNode(a);
            if(head==null){
                head=listNode;
                last=listNode;
            }else{
                listNode.next=head;
                head.prev=listNode;
                head=listNode;
            }
    }

 addLast——尾插 

实现思路与头插法类似：

  1. 判断链表是否为空，如果为空，则将头结点 head 和尾结点 last 都指向新节点 listNode。

  2. 如果链表不为空，将新节点 listNode 的 prev 指针指向当前的尾结点 last，将当前的尾结点 last 的 next 指针指向新节点 listNode，然后将尾结点 last 更新为新节点 listNode。

     public  void addLast(int a){
            ListNode listNode = new ListNode(a);
            if(last==null){
                head=listNode;
                last=listNode;
            }else{
                listNode.prev=last;
                last.next=listNode;
                last=listNode;
            }
    }

addIndex——在任意位置插入 

具体实现步骤如下：

  1. 判断链表是否为空。如果为空，则新建一个节点listNode，并将头结点head指向listNode，然后返回。

  2. 判断index是否越界。如果小于0或者大于链表长度size()，则抛出自定义异常MyIndexException，打印异常堆栈信息，然后返回。

  3. 如果index等于0，则调用addFirst(a)方法在链表头部添加元素a，然后返回。

  4. 如果index等于size()，则调用addLast(a)方法在链表尾部添加元素a，然后返回。

  5. 否则，新建一个节点listNode，并遍历链表找到第index-1个节点cur。

  6. 将cur节点的后继节点的前驱指针指向listNode节点。

  7. 将listNode节点的前驱指针指向cur节点。

  8. 将listNode节点的后继指针指向cur节点的后继节点。

  9. 将cur节点的后继指针指向listNode节点。

​
public void addIndex(int index,int a){
        if(head==null){
            ListNode listNode = new ListNode(a);
            head=listNode;
            return;
        }
        if(index<0||index>size()){
            try{
                throw new  MyIndexException("位置不合法");
            }
            catch(Exception e){
              e.printStackTrace();
            }
            return;
        }
        if(index==0){
            addFirst(a);
            return;
        }
        if(index==size()){
            addLast(a);
            return;
        }
        ListNode listNode = new ListNode(a);
        ListNode cur=head;
        for (int i = 0; i <index-1 ; i++) {
            cur=cur.next;
        }
        cur.next.prev=listNode;
        listNode.prev=cur;
        listNode.next=cur.next;
        cur.next=listNode;

    }

​class MyIndexException extends RuntimeException{
    public MyIndexException(String message) {
        super(message);
    }
}

 contains——判定是否包含某个元素 

   比较简单，遍历这个数组即可

  public void  contain(int key){
        ListNode cur=head;
        while(cur!=null){
            if(cur.val==key){
                System.out.println(true);
                return;
            }
            cur=cur.next;
        }
        System.out.println(false);
    }

 因为这里我们存放的是 int 类型的变量，但 LinkedList 当中是存放引用数据类型的
⚠️⚠️⚠️当表中是引用类型时，就不可以用“等号”比较，应该用 equals 方法

remove——删除第一次出现关键字为key的结点 

首先判断链表是否为空，若为空则输出“为空链表，不能进行删除操作”，并直接返回。

若链表不为空，则判断头节点head的值是否等于给定key值。如果是，将head指向下一个节点，并将原来的head节点删除。如果此时head已经变成空节点，说明该链表只有一个节点，直接更新last为null；否则，将head节点的前驱指针设为null。

如果头节点的值不等于给定key值，则从头节点的后继开始遍历链表。当遇到某个节点的值等于给定key值时，将该节点的前驱节点指向该节点的后继节点，并将该节点删除。

如果整个链表中不存在值等于给定key值的节点，则输出“不存在该数”

   public void remove(int key){
        ListNode cur=head;
        if(head==null) {
            System.out.println("为空链表，不能进行删除操作");
            return;
        }
        if(cur.val==key) {
            head=head.next;
            if(head==null){
                last=null;
            }else
                head.prev=null;

            return;
        }
        while(cur.next!=null){
            if(cur.next.val==key){
                cur.next.next.prev=cur;
                cur.next=cur.next.next;
                return;
            }
            cur=cur.next;
        }
        System.out.println("不存在该数");
    }

 removeAll——删除所有值为key的结点  

首先判断链表是否为空，如果为空则无法进行删除操作，直接返回。

然后从头节点开始遍历链表，每次检查当前节点的下一个节点的值是否等于 key，如果相等，则把当前节点的下一个节点删除（即把当前节点的 next 指针指向下下个节点），同时要把下下个节点的 prev 指针指向当前节点。

如果当前节点的下一个节点的值不等于 key，则把当前节点移动到下一个节点。

最后，如果头节点的值等于 key，需要特殊处理头节点，将头节点指向下一个节点。如果此时头节点已经为空，则需要将尾节点也设为 null；否则我们就将新的头节点的 prev 指针设为 null。

public void removeAll(int key){
        if(this.head == null) {
            System.out.println("为空链表，不能进行删除操作");
            return;
        }
        ListNode cur = head;
        while(cur.next != null){
            if(cur.next.val == key){
                cur.next.next.prev=cur;
                cur.next=cur.next.next;
            }
            else {
                cur = cur.next;
            }}

        if(head.val==key){
            head = head.next;
            if(head==null){
                last=null;
            }else
                head.prev=null;
        }
    }

clear——清空单链表  

该方法首先要判断头节点是否为空，若为空，则直接返回。若不为空，则通过一个while循环，将每个节点的前驱和后继均置为null，以便垃圾回收机制及时回收节点所占用的内存。最后，将头节点和尾节点均置为null，以实现链表清空。

如果节点中的val是引用类型，则需要将其也全变为null。基本类型则不需要。

   public void clear(){
            while (head==null)
                return;
            ListNode cur=head;
            while (cur!=null){
                cur.prev=null;
                ListNode temp=cur.next;
                 cur.next=null;
                 cur=temp;
    }
            head=null;
            last=null;

        }

当然也存在暴力解法，就是直接将head=null，last=null，也能得到一样的效果。

  public void clear(){
            head=null;
            last=null;
        }

此时链表中的各个节点中 就不存在 有固定存在的引用去指向它们，它们节点自己的互相指向就形成了个死循环，此时系统就默认将这些节点自动回收掉，所以能得到一样的效果。

对于无头单向非循环链表中的clear我们采用的是暴力解法，当然也可以像这里一样把引用变量全都变为null，都是可取的，效果一样。我个人还是比较喜欢暴力解法。

2.3完整代码及使用

完整代码

​
public class MyLinkedList {
    static class ListNode{
        int val;
        ListNode next;
        ListNode  prev;

        public ListNode(int val) {
            this.val = val;
        }
    }
        ListNode head;
        ListNode  last;


        public void display(){
            ListNode cur=head;
            if(head==null)
                return;
            while(cur!=null){
                System.out.print(cur.val+"  ");
                cur=cur.next;
            }
            System.out.println();
        }
           public int size(){
            ListNode cur=head;
            int count=0;
            while(cur!=null){
               cur =cur.next;
               count++;
            }
            return  count;
           }

           public  void addFirst(int a){
            ListNode listNode = new ListNode(a);
            if(head==null){
                head=listNode;
                last=listNode;
            }else{
                listNode.next=head;
                head.prev=listNode;
                head=listNode;
            }
    }

       public  void addLast(int a){
            ListNode listNode = new ListNode(a);
            if(last==null){
                head=listNode;
                last=listNode;
            }else{
                listNode.prev=last;
                last.next=listNode;
                last=listNode;
            }
    }

    public void addIndex(int index,int a){
        if(head==null){
            ListNode listNode = new ListNode(a);
            head=listNode;
            return;
        }
        if(index<0||index>size()){
            try{
                throw new  MyIndexException("位置不合法");
            }
            catch(Exception e){
              e.printStackTrace();
            }
            return;
        }
        if(index==0){
            addFirst(a);
            return;
        }
        if(index==size()){
            addLast(a);
            return;
        }
        ListNode listNode = new ListNode(a);
        ListNode cur=head;
        for (int i = 0; i <index-1 ; i++) {
            cur=cur.next;
        }
        cur.next.prev=listNode;
        listNode.prev=cur;
        listNode.next=cur.next;
        cur.next=listNode;

    }
    public void remove(int key){
        ListNode cur=head;
        if(head==null) {
            System.out.println("为空链表，不能进行删除操作");
            return;
        }
        if(cur.val==key) {
            head=head.next;
            if(head==null){
                last=null;
            }else
                head.prev=null;

            return;
        }
        while(cur.next!=null){
            if(cur.next.val==key){
                cur.next.next.prev=cur;
                cur.next=cur.next.next;
                return;
            }
            cur=cur.next;
        }
        System.out.println("不存在该数");
    }

    public void removeAll(int key){
        if(this.head == null) {
            System.out.println("为空链表，不能进行删除操作");
            return;
        }
        ListNode cur = head;
        while(cur.next != null){
            if(cur.next.val == key){
                cur.next.next.prev=cur;
                cur.next=cur.next.next;
            }
            else {
                cur = cur.next;
            }}

        if(head.val==key){
            head = head.next;
            if(head==null){
                last=null;
            }else
                head.prev=null;
        }
    }
    public void clear(){
            while (head==null)
                return;
            ListNode cur=head;
            while (cur!=null){
                cur.prev=null;
                ListNode temp=cur.next;
                 cur.next=null;
                 cur=temp;
    }
            head=null;
            last=null;

        }
    public void  contain(int key){
        ListNode cur=head;
        while(cur!=null){
            if(cur.val==key){
                System.out.println(true);
                return;
            }
            cur=cur.next;
        }
        System.out.println(false);
    }


}

​class MyIndexException extends RuntimeException{
    public MyIndexException(String message) {
        super(message);
    }
}

 完整代码的使用

public class Test {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.addFirst(110);
        myLinkedList.addFirst(15);
        myLinkedList.addLast(45);
        myLinkedList.addLast(64);
        myLinkedList.addLast(43);
        myLinkedList.addIndex( 4,45);
        myLinkedList.addFirst(45);
        myLinkedList.display();
        myLinkedList.remove(15);
        myLinkedList.removeAll(45);
        myLinkedList.display();
        myLinkedList.contain(110);
        System.out.println(myLinkedList.size());
    }
}

3.总结

这篇文章我们就将无头双向非循环链表的模拟讲清楚了，它跟无头单向非循环链表的模拟很相似，但还是有一点区别的。我们下篇文章将给大家带来LinkedList的使用。在此，我们诚挚地邀请各位大佬们为我们点赞、关注，并在评论区留下您宝贵的意见与建议。让我们共同学习，共同进步，为知识的海洋增添更多宝贵的财富！🎉🎉🎉❤️❤️💕💕🥳👏👏👏

E绵绵
关注
  • 8
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java 集合与数据结构详解1
08-03
本文将深入探讨Java集合框架的核心概念、数据结构以及相关的算法。 首先，集合框架主要由两个核心部分组成：集合（Collection）和图（Map）。集合是用来存储单一元素的容器，而图则用于存储键值对映射关系。在...
3.5W 字详解 Java 数据结构.pdf
11-18
本文主要探讨了Java集合框架中的核心概念，特别是`Iterable`和`Collection`接口，以及它们如何构成了Java数据结构的基础。 首先，`Iterable`接口是所有可以迭代的对象的基接口，它定义了一个单一的方法`iterator()`...
Java数据结构：详解及使用场景.pdf
11-18
这些Java数据结构在实际编程中有着广泛的应用。例如： - 数组适用于存储固定大小且类型相同的元素集合，常用于基础计算和内存效率要求高的场景。 - 列表（如ArrayList和LinkedList）在需要动态调整大小和频繁增删...
Java 数据结构链表操作实现代码
09-01
链表是一种重要的数据结构，它不同于数组，不连续存储元素，而是通过节点间的引用关系连接。在Java中，我们可以使用对象来实现链表。链表分为单链表、循环链表和双向链表。 单链表是每个节点包含数据部分和指向下一...
java LinkedList的实例详解
08-29
Java LinkedList是一种基于链表的数据结构，在Java语言中广泛应用于实现队列、栈、双端队列等数据结构。下面将对Java LinkedList的实例进行详细的解释。 1. LinkedList类结构 Java LinkedList的实现基于链表结构，...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1192
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 483
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
weixin_43561432的博客
07-24 263
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1952
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1343
Java实现拼图小游戏
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 1000
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 234
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 848
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
学习笔记---java篇（0723）
m0_70630166的博客
07-23 762
java、数据类型、循环、选择等
4.Jmeter接口性能测试
weixin_43444329的博客
07-23 718
系统用户数：软件系统注册的用户总数（要注意初始化环境）在线用户数：某段视角内访问用户数，这些用户只是咋先，不一定同时做某一件事情。（初始化环境（warm up热机：让系统接近运行的系统，让系统运行更快 磁盘->内存））并发用户数：某一个时间同时向系统提交请求的用户数，场景不一定是同一个。：测试web系统的性能，支持多少并发？在确定并发用户数之前，必须先对用户的业务进行分解，分析出其中的典型业务场景（用户最常用、最关注的业务操作）然后基于场景获得其并发用户数。
19.jdk源码阅读之FutureTask
最新发布
前端、移动端、后端源码级底层原理分享
07-25 542
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
c++ 智能指针shared_ptr与make_shared
Txwtech笛克特科
07-25 107
shared_ptr是C++11引入的一种智能指针，‌它允许多个shared_ptr实例共享同一个对象，‌通过引用计数来管理对象的生命周期。‌当最后一个持有对象的shared_ptr被销毁时，‌它会自动删除所指向的对象。‌这种智能指针主要用于解决资源管理问题，‌避免内存泄漏。make_shared是C++标准库中的一个函数，‌用于创建一个shared_ptr智能指针，‌它接受一个或多个参数来构造一个对象，‌并返回一个指向该对象的shared_ptr。类SerialModbus的成员指针。
Java的集合框架（Collection Framework）中的Iterator接口详解
m0_49013185的博客
07-22 624
在Java中，将Iterator定义为接口是一种设计上的选择，目的是提供一个统一的迭代机制，使不同类型的集合都能以一致的方式进行遍历。以下是将Iterator以下是IteratorE next();将Iterator定义为接口的主要目的是提供一个统一、灵活且可扩展的迭代机制。通过这种方式，Java集合框架能够支持多种类型的集合，并且客户端代码能够以一致的方式使用这些集合。这种设计不仅简化了集合的使用，还提高了代码的可维护性和可扩展性。
mysql表设计
wwwwwww31311的博客
07-23 155
status 状态 java代码中用一个枚举类，比如我的请假表还处于草稿状态，可以是新建态，提交后处于待审批状态，审批完成则是成功态，审批拒绝就是拒绝态。start_time 开始时间 dateTime类型。end_time 起始时间 dateTime类型。employee_id 外键，和员工信息表想管理。type 请假类型，对应一个枚举类，病假，事假。create_time 请假记录的创建时间。如果让你设计一个请假表，如何设计？approve_id 外键。
Java LinkedList详解：双向链表操作与示例应用
在Java编程中，LinkedList是一种重要的数据结构，它是`java.util.LinkedList`类，属于`java.util`包下的一个实现双向链表的数据结构。LinkedList的设计使得它具有多种操作方式，包括队列、堆栈以及双端队列的功能，...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值