【JavaSE】双向链表的实现与讲解

最新推荐文章于 2024-11-12 18:03:10 发布
最新推荐文章于 2024-11-12 18:03:10 发布
阅读量494 收藏
点赞数 1
分类专栏： Java学习之旅 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xqs196301/article/details/122113706
版权

上次文章我们实现了单向链表，链接如下 ： 单向链表的实现与讲解
而这篇文章博主就对双向链表如何实现以及实现原理进行讲解；
双向链表和单向链表本质上区别不大，双向链表就比单向链表每个节点多了一个先驱prev，以实现链表能够逆向链接：
在这里插入图片描述
双向链表需要有一个头结点引用head 以及一个尾结点引用last
而有力单向链表的知识基础，双向链表实现以及理解上就会容易很多，讲解如下 ：

快速跳转：

1.节点类实现

class ListNode{
    public int val; //数据域
    public ListNode prev;//前驱域
    public ListNode next;//后驱域

    public ListNode(int val){ //一个参数的构造方法 实现对数据域的数据赋值
        this.val=val; //this : 表示当前对象引用（注意不是当前对象）
    }
}

2. 双向链表各个模块功能实现

2.1 头插法

//头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data); //实例化插入的节点
        if (this.head == null) {//链表为空情况
            this.head = node;
            this.last = node;
        } else { 
            node.next = this.head; //node的next改为head
            this.head.prev = node; //head的prev改为node
            this.head = node; //此时新的head为node
        }
    }

在这里插入图片描述

2.2 尾插法

//尾插法
    public void addLast(int data) {
        ListNode node = new ListNode(data);//实例化插入的节点
        if (head == null) { //链表为空情况
            this.head = node;
            this.last = node;
        } else {
            this.last.next = node; //last尾结点的next改为node 
            node.prev = this.last; //node的前驱prev改为last
            this.last = node; //此时last为node 
        }
    }

在这里插入图片描述

2.3 查找关键字key是否在单链表当中

 //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key){
        ListNode cur=this.head; //定义cur引用指向head
        while (cur!=null){ //遍历链表
            if (cur.val==key){
                return true; //找到返回TRUE
            }
            cur=cur.next; //没找到继续找下一个节点
        }
        return false; //遍历完成没有返回true 则没有找到 返回false 
    }

在这里插入图片描述

2.4 删除第一次出现关键字为key的节点

单向链表删除节点操作要先找到需要删除的那个节点的前一个节点，在进行删除操作；而双向链表不需要找前一个节点，找到要删除的节点它本身就可以进行操作


    //删除第一次出现关键字为key的节点
    public void remove(int key){
        ListNode cur=this.head; //cur引用来遍历
        while(cur!=null){ //遍历
            if (cur.val==key){ 
                if (cur==head){ //要删除的节点是头节点情况
                    head=head.next; //head直接引用向下一个节点
                    if（head！=null）{
                    head.prev=null; //下一个节点的prev改为null
                    }else{
                    last=null； //因为last是成员变量 不手动制空会一直浪费着内存
                    }
                }else if(cur==last){ //删除节点是尾结点情况
                    cur.prev.next=cur.next; //尾结点的前一个节点的next改为此时尾结点的next 也就是null
                    last=last.prev; //last引用向前一个节点 实现删除
                }else{ //节点既不是头结点也不是尾结点的情况
                    cur.prev.next=cur.next; //前一个节点的next直接指向后一个节点 
                    cur.next.prev=cur.prev; //后一个节点的prev直接指向前一个节点  实现删除
                }
                return; //只删除一个 删除执行的话返回 
            }else{
                cur=cur.next; //没有找到的话  继续查找下一个节点
            }
        }
    }

在这里插入图片描述

2.5 删除所有值为key的节点

步骤与删除一次key相同 只是在删除操作后不return 继续进行遍历删除

 //删除所有值为key的节点
    public void removeAllKey(int key){
        ListNode cur=this.head;
        while(cur!=null){
            if (cur.val==key){
                if (cur==head){
                    head=head.next;
                    if(head!=null){
                        head.prev=null;
                    }else{
                        last=null;
                    }
                }else if(cur==last){
                    cur.prev.next=cur.next;
                    last=last.prev;
                }else{
                    cur.prev.next=cur.next;
                    cur.next.prev=cur.prev;
                }
                // return; 删除一次是直接return 删除所有的话就不return 继续进行遍历删除
            }else{
                cur=cur.next;
            }
        }

    }

2.6 得到单链表的长度

//得到单链表的长度
    public int size(){
        ListNode cur=this.head; //cur引用来遍历
        int count=0; //计数器
        while (cur!=null){ //遍历操作
            count++; 
            cur=cur.next; 
        }
        return count; //返回长度 
    }

2.7 打印单链表

 public void display(){
        ListNode cur=this.head;//cur引用来遍历
        while(cur!=null){//遍历 
            System.out.print(cur.val+" ");
            cur=cur.next;
        }
        System.out.println(); 
    }

2.8任意位置插入,第一个数据节点为0号下标

回顾上次的单向链表，我们要在index位置插入需要找到index位置前面一个节点，而这里的双向链表 我们要在index插入 就只需要找到index位置的节点进行操作
首先我们要完成一个查找index位置节点的方法

 public ListNode searchIndex(int index){
       ListNode cur=this.head; 
       while (index!=0){ 
           cur=cur.next;
           index--;
       }
       return cur; //找到index位置的节点进行返回
     }

进行插入操作 ：

  //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data){
       ListNode node=new ListNode(data); //实例化需要插入的节点
       if (index<0 || index>size()){ //判断index是否合法
           System.out.println("index位置不合法！");
           return;
       }
       if (index==0){ //头插法 
           addFirst(data);
           return;
       }
       if (index==size()){// 尾插法
           addLast(data);
           return;
       }
       ListNode cur=searchIndex(index); //找到index位置节点定义为cur
       // 进行插入操作 ：插入操作需要改变**4个**引用域的值 实现插入 
       node.next=cur.prev.next; 
       cur.prev.next=node;
       node.prev=cur.prev;
       cur.prev=node;
    }

在这里插入图片描述
需要改变的4个引用域就是蓝色圈起来的4个引用域 具体改变代码 ：

node.next=cur.prev.next; 
       cur.prev.next=node;
       node.prev=cur.prev;
       cur.prev=node;

照着进行画图就能很容易理解 ~

2.9 清空链表

public void clear(){
//不采用直接把head last制空的暴力情况方法 
//而是采取逐一情况prev last的操作
        ListNode cur=this.head;
        while(cur!=null){
            ListNode curNext=cur.next;
            cur.prev=null;
            cur.next=null;
            cur=curNext;
        }
        //不要忘记把head last 引用也制空
        this.head=null;
        this.last=null;
    }

在这里插入图片描述
清空成功 ！

3. 整体 MyLinkedList 代码展示

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

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

public class MyLinkedList {
    ListNode head;
    ListNode last;

    // 2、无头双向链表实现

    //头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        if (this.head == null) {
            this.head = node;
            this.last = node;
        } else {
            node.next = this.head;
            this.head.prev = node;
            this.head = node;
        }
    }

    //尾插法
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if (head == null) {
            this.head = node;
            this.last = node;
        } else {
            this.last.next = node;
            node.prev = this.last;
            this.last = node;
        }
    }

     public ListNode searchIndex(int index){
       ListNode cur=this.head;
       while (index!=0){
           cur=cur.next;
           index--;
       }
       return cur;
     }


    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data){
       ListNode node=new ListNode(data);
       if (index<0 || index>size()){
           System.out.println("index位置不合法！");
           return;
       }
       if (index==0){
           addFirst(data);
           return;
       }
       if (index==size()){
           addLast(data);
           return;
       }
       ListNode cur=searchIndex(index);
       node.next=cur.prev.next;
       cur.prev.next=node;
       node.prev=cur.prev;
       cur.prev=node;
    }

    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key){
        ListNode cur=this.head;
        while (cur!=null){
            if (cur.val==key){
                return true;
            }
            cur=cur.next;
        }
        return false;
    }


    //删除第一次出现关键字为key的节点
    public void remove(int key){
        ListNode cur=this.head;
        while(cur!=null){
            if (cur.val==key){
                if (cur==head){
                    head=head.next;
                    if(head!=null){
                        head.prev=null;
                    }else{
                        last=null;
                    }
                }else if(cur==last){
                    cur.prev.next=cur.next;
                    last=last.prev;
                }else{
                    cur.prev.next=cur.next;
                    cur.next.prev=cur.prev;
                }
                return;
            }else{
                cur=cur.next;
            }
        }
    }


    //删除所有值为key的节点
    public void removeAllKey(int key){
        ListNode cur=this.head;
        while(cur!=null){
            if (cur.val==key){
                if (cur==head){
                    head=head.next;
                    if(head!=null){
                        head.prev=null;
                    }else{
                        last=null;
                    }
                }else if(cur==last){
                    cur.prev.next=cur.next;
                    last=last.prev;
                }else{
                    cur.prev.next=cur.next;
                    cur.next.prev=cur.prev;
                }
                // return;
            }else{
                cur=cur.next;
            }
        }

    }
    //得到单链表的长度
    public int size(){
        ListNode cur=this.head;
        int count=0;
        while (cur!=null){
            count++;
            cur=cur.next;
        }
        return count;
    }

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

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

}

4. 部分测试 test 代码展示 ：

public class TestDemo {
    public static void main(String[] args) {
        MyLinkedList myLinkedList=new MyLinkedList();
        myLinkedList.addFirst(1);
        myLinkedList.addFirst(2);
        myLinkedList.addFirst(3);
       // System.out.println(myLinkedList.size());
        myLinkedList.display();
      //  System.out.println(myLinkedList.contains(2));
      //  myLinkedList.remove(3);
      //  myLinkedList.display();
        System.out.println("-------------------");

        myLinkedList.clear();
        myLinkedList.display();

    }

}

在这里插入图片描述

5. 总结

讲解到这里 双向链表的实现就已经完成了
对于链表的学习我们一定要多画图理解 多思考 多写代码 才能真正学好链表

如果觉得博主的文章对自己有所帮助 欢迎大家多多点赞收藏 ~

小轩在不在哟
关注
专栏目录
数据结构之双向链表详解
小源_ 的博客
12-20 3656
本文着重讲解了LinkedList(无头双向单链表)的实现和LinkedList的使用。内附代码和图文分析，看完就会！
JavaSE_集合.pdf
02-02
- **LinkedList**使用双向链表实现，适用于频繁的增删操作，查询效率较低。 #### 五、Set接口 - **Set**接口继承自Collection，不允许元素重复，不保证元素的顺序。 - **HashSet**实现了Set接口，底层使用哈希表...
【数据结构】双向链表你必须知道的内部原理！！！
GGBond778的博客
08-08 1224
了解双向链表，看这一篇就够了，本篇将从底层代码模拟开始，到常用的LinkedList方法的使用，与遍历进行逐步讲解。
Java【链表】详细图解/ 模拟实现+【LinkedList】常用方法介绍
yzhcjl_的博客
02-12 2043
以上就是今天分享的关于数据结构中【链表】的内容，一方面介绍了如何模拟实现简易的单链表，一方面介绍了Java集合框架中的 LInkedList 类的基本使用，并且分析了链表和顺序表的区别对比上山总比下山辛苦下篇文章见。
【JAVA-数据结构】LinkedList与链表
Mr_star_galaxy的博客
10-11 1024
LinkedList 的官方文档LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高【说明】1. LinkedList实现了List接口2. LinkedList的底层使用了双向链表3. LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问。
php栈链表,PHP算法学习（6） 单向链表 实现栈
weixin_33240461的博客
03-16 142
svn地址：svn://gitee.com/zxadmin/live_z这个是模拟栈的先进后出的一个链表操作，自动维护链表，当然你也使用SPL的栈测试版本php 5.4 ，5.6，7.0,7.2/** 链表测试到辅助类*/final class Node {public $data;public $next = null;public function __construct($data) {$t...
JavaSe对集合类的详细讲解
欢迎阅读我的博客
02-27 244
集合实际上就是一个容器 , 可以动态的容纳不同类型的对象。数组也是一个集合但它长度一旦确定就不能更改集合是一个载体 , 可将数据库中查询到的10条记录封装成10个java对象放到某一个集合当中并传到前端，然后前端遍历这个集合做数据展示集合不能直接存储基本数据类型和 java 对象 ,集合中存储的都是堆中某个java对象的内存地址 ,list.add(100)是发生了自动装箱所有的集合类和集合接口都在java.util包下, 每一个不同的集合底层会对应不同的数据结构。
JavaSE中所有集合保姆级讲解
C_x_330的博客
04-29 857
JavaSE笔记-泛型与集合类
a35065521的博客
05-06 829
JavaSE笔记-泛型与集合类 在前面我们学习了最重要的类和对象，了解了面向对象编程的思想，注意，非常重要，面向对象是必须要深入理解和掌握的内容，不能草草结束。在本章节，我们会继续深入了解，从我们的泛型开始，再到我们的数据结构，最后再开始我们的集合类学习。 走进泛型 为了统计学生成绩，要求设计一个Score对象，包括课程名称、课程号、课程成绩，但是成绩分为两种，一种是以优秀、良好、合格 来作为结果，还有一种就是 60.0、75.5、92.5 这样的数字分数，那么现在该如何去设计这样的一个Score类呢？现在
【数据结构】 LinkedList的模拟实现与使用
m0_71731682的博客
08-23 3462
LinkedList 的官方文档LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。// add(elem): 表示尾插 list . add(2);// 在起始位置插入0 list . add(0 , 0);
b-javase.zip_java
09-23
LinkedList则基于双向链表，更适合频繁的插入和删除操作。HashSet存储不重复元素，HashMap则用于存储键值对，提供快速查找功能。 其次，Java的I/O流系统支持对文件、网络和内存的数据读写。InputStream和...
JavaSE基础入门视频教程33天之（19） part2
09-09
LinkedList是一种双向链表，它不仅支持按索引访问，还可以高效地在链表的任何位置插入和删除元素。特有的方法如addFirst、addLast、removeFirst、removeLast等，使得LinkedList在处理需要频繁插入和删除的场景时，比...
C++研发笔记12——C语言程序设计初阶学习笔记10
Lbs_gemini0603的博客
11-09 583
C++研发笔记12——C语言程序设计初阶学习笔记10
数据结构（1）
m0_71616132的博客
11-09 644
数据结构
数据结构-图的概念
dametime_的博客
11-09 208
修路问题将各个村庄相连,由于经费有限,只能选择将各个村庄联通为先。不存在空图现象,顶点集不能为空,边集可以为空。对于一个生成树,他有n个节点就有n-1条边。研究链接一个顶点的边有多少条非常有意义。将村庄图生成树或生成森林,选择最有路线。子图必须联通,尽可能多的边和结点。有向图的入度=出度,度=边数。给每条边赋权值解决相关问题。无向图的度=边的二倍。
C语言第十一周课——函数的调用
qq_58156721的博客
11-12 135
学习函数的调用:通过调用函数来实现二分法。通过调用函数来实现冒泡法。
数据结构：时间复杂度&空间复杂度
小黄鸭的博客
11-09 925
因此衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，即。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。
数据结构合并两个有序链表
weixin_60489641的博客
11-09 238
循环条件为list1与list2均不为null，开始比较list1和list2中的大小，如果是最小值将其放入nextHead的数组中，然后list1走到下一个节点继续与list2匹配，每次都将最小值或相等值放入合并的链表中。这里我们可以创建一个新的对象作为合并后的新链表newHead，而NewHead.next就是我们要返回的头部的位置。在创建一个对象来获取nextHead.next下一个节点来作为我们新链表的起始位置防止我们的头部位置找不到。然后将list2的目标节点放入nextHead.next中。
希尔排序（C语言）
最新发布
N_N12的博客
11-12 411
希尔排序是在直接插入排序的基础上演变的1.先选定一个小于n的整数gap作为间隔（一般gap = n / 3 + 1），然后将所有距离为gap的元素分在同一组，并对每一组的元素进行直接插入排序。它将一组数组分为了gap组，一组中每个元素的间隔为gap。2.当gap的大小减到1时，就相当于整个序列被分到一组，进行一次直接插入排序，排序完成。图片讲解将上述同一颜色相连的数分为一组，一共分了gap组，一组中每个元素的间隔为gap，对同一组中的元素进行插入排序。
JavaSE编程：实现监听器接口详解
"JavaSE核心编程 - 步骤实现监听器接口" 在JavaSE核心编程中，事件监听是构建图形用户界面（GUI）时的重要组成部分。监听器接口允许程序响应用户的特定行为，如按钮点击、鼠标移动或键盘输入。本示例主要关注如何...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值