Java：链表

已于 2024-03-30 19:12:56 修改
阅读量1k 收藏 29
点赞数 26
文章标签： java 链表 开发语言
于 2024-03-30 18:55:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wu_yi_min/article/details/137098026
版权

一、链表简介

1、链表与顺序表的区别

上一篇博客我介绍了顺序表，这次我们来认识认识链表！先来看看二者的区别：

顺序表：由于顺序表实际上是一个数组，因此它在物理上是连续的，逻辑上也是连续的！

链表    ：链表实际上是由一块一块的内存组成，因此物理上表示连续的，但是在逻辑上是连续的！

链表的一个生动例子也就是我们日常出行可见的火车高铁！大家想想看：火车是不是有一节一节的车厢连接而成？在就很我们要学习的链表很相似了！链表也是由一块一块的内存连接而成！

如图：

链表是由一个一个的节点组织起来的，整体就叫做链表！

2、链表分类：

分类的几种标准：

单向           双向

带头           不带头

循环           非循环 

根据以上标准，链表基本划分为八种：

单向带头循环、单向带头非循环、单向不带头循环、单向不带头非循环

双向带头循环、双向带头非循环、双向不带头循环、双向不带头非循环

全部讲解不太现实，也没有必要，我们只要认识两种比较重要的类型就行了！接下来我们主要认识的是：

单向不带头非循环、双向不带头非循环

3、通过画图认识几种类型：

单向不带头非循环：

如图：

1、每一个节点由两个域构成，分别是value和next，value存储这个节点的数据，next存储下一个节点的地址！

2、单向的意思是这个链表只有一个方向，即箭头方向

3、不带头表示表示这个链表没有头，而是指这个链表的头不固定！

如这个例子，现在这个头的地址为第一个节点的地址0x12，如果把第一个节点删除，那么这个头的地址也就修改为第二个节点的地址0x33

单向带头非循环： 

 与前面的单向不带头非循环对比，区别是这个类型带了一个固定的头，它永远不会变！

如图：

循环类型： 

循环类型与非循环类型的区别在于，最后一个节点存储的地址是不是为null？

非循环：最后一个节点存储的地址为null

循环   ：最后一个节点存储的地址为第一个节点的地址 

如图：这个为循环类型

二、链表的实现

全部代码：

1、链表类代码：

public class MySingleLinkedList {

    //链表是由一个个节点构成，因此我们可以抽象出一个节点类
    class ListNode{
        public int val;
        public ListNode next;

        //创建构造方法
       public  ListNode(int val){
            this.val=val;
        }
    }

    //链表的头节点
    public ListNode head;

    //创建一个小链表的方法：
    public void create(){
        ListNode node1=new ListNode(1);
        ListNode node2=new ListNode(2);
        ListNode node3=new ListNode(3);
        ListNode node4=new ListNode(4);

       //通过地址连接链表
        node1.next=node2;
        node2.next=node3;
        node3.next=node4;
        head=node1;
    }

    //打印链表的方法：
    public void display(){
        ListNode cur=head;
        while(cur!=null){
            System.out.print(cur.val+" ");
            cur=cur.next;
        }
    }

    //求链表长度的方法：
    public int size(){
        ListNode cur=head;
        int count=0;
        while(cur!=null){
            count++;
            cur=cur.next;
        }
        return count;
    }

    //头插的方法：
    public void addFirst(int val){
        ListNode node=new ListNode(val);
        node.next=head;
        head=node;
    }

    //尾插的方法：
    public void addLast(int val){
        ListNode node=new ListNode(val);
        //如果head为空
        if(head==null){
            head=node;
            return ;
        }


        //当head不为空
        ListNode cur=head;
        //找到尾节点
        while(cur.next!=null){
            cur=cur.next;
        }
        cur.next=node;
    }

    //任意位置插入的方法：
    public void addIndex(int index,int val){
        //检查index是否合法
        try{
            checkIndex(index);
        }catch (IndexNotLeaglException e){
            e.printStackTrace();
        }

        //index==0,相当于头插
        if(index==0){
            addFirst(val);
            return;
        }

        //index=size,相当于尾插
        if(index==size()){
            addLast(val);
            return;
        }

        //0<index<size
         if(index>0&&index<size()){
            ListNode node=new ListNode(val);
            ListNode cur=findIndexSubOne(index);
            node.next=cur.next;
            cur.next=node;
        }

        }


    //找到index的前一个位置的方法：
    private ListNode findIndexSubOne(int index){
        ListNode cur=head;
        int count=0;
        while(count!=index-1){
            cur=cur.next;
            count++;
        }
        return cur;
    }


    //检查index是否合法
    private void checkIndex(int index){
        if(index<0||index>size()){
            throw new IndexNotLeaglException("index不合法！");
        }
    }

    //查找是否包含某个关键字key的方法：
    public boolean contains(int key){
        ListNode cur=head;
        while(cur!=null) {
            if(cur.val==key){
                return true;
            }
            cur=cur.next;
        }
        return false;
    }


    //删除链表中第一次出现关键字key的节点方法：
    public void remove(int key){

     //1、删除头节点
        if(head==null){
            return;
        }
        if(head.val==key){
            head=head.next;
            return;
        }

     //2、要删除的元素不在头节点

     //先找到要删除的前一个节点
       ListNode cur=head;
       while(cur.next!=null){
           if(cur.next.val==key){
               break;
           }
           cur=cur.next;
       }
       //删除该节点
        cur.next=cur.next.next;
    }


    //去除链表中所有相同的关键字
    public void removeAllKey(int key){

        if(head==null){
            return;
        }
        //1、先去除头节点以外的与key相同值的节点
        ListNode prev=head;//cur的前驱节点
        ListNode cur=head.next;//寻找要去除的节点

        //判断并且删除节点
        while(cur!=null){
            if(cur.val==key){
                prev.next=cur.next;
                cur=cur.next;
            }else{
                prev=cur;
                cur=cur.next;
            }
        }

        //2、判断头节点存储的内容是否为key
        if(head.val==key){
            head=head.next;
        }
    }
}

2、异常类代码： 

public class IndexNotLeaglException extends RuntimeException{
    IndexNotLeaglException(){

    }
    IndexNotLeaglException(String msg){
        super(msg);
    }
}

全部类文件： 

  代码讲解： 

1、类文件

如图，为了实现链表，我们创建了两个类：MySingleLinkedList类和Test类

MySingleLinkedList类：主要是用来创建链表和实现链表的具体功能！

Test类：主要是用来测试和使用链表

2、创建节点类 

   我们知道，链表是由一个一个的节点构成的，每个节点由value（节点的内容）和next（下一个节点的地址）构成，那么在自己实现链表的过程中，我们就可以抽象出来一个节点类，包含两个成员变量val和next。

   此时这个ListNode类定义在MySingleLinkedList类的内部，称为内部类！

   另外，由于链表需要一个头，方便我们遍历链表，因此我们可以定义一个ListNode类型的引用变量head，用来存储第一个节点的地址！

public class MySingleLinkedList {

    //链表是由一个个节点构成，因此我们可以抽象出一个节点类
    class ListNode{
        public int val;
        public ListNode next;

        //创建构造方法
       public ListNode(int val){
            this.val=val;
        }
    }

    //链表的头节点
    public ListNode head;
    
}

3、创建链表方法： 

我们知道，链表的底层不像顺序表，它不是由数组构成，而是由一个一个的节点连接而成！

因此我们在创建链表的时候，需要实例化一个一个的ListNode类！这里我们可以实现一个方法，帮助我们创建一个小链表！ 

//创建一个小链表
    public void create(){
        ListNode node1=new ListNode(1);
        ListNode node2=new ListNode(2);
        ListNode node3=new ListNode(3);
        ListNode node4=new ListNode(4);

       //通过地址连接链表
        node1.next=node2;
        node2.next=node3;
        node3.next=node4;
        head=node1;
    }

3、打印链表方法：

为了知道链表中存储了什么内容，我们可以实现一个打印链表的方法！

//打印链表方法：
    public void display(){
        ListNode cur=head;
        while(cur!=null){
            System.out.print(cur.val+" ");
            cur=cur.next;
        }
    }

4、求链表长度方法： 

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

 5、头部插入方法

在第一个节点之前插入一个新的节点：

首先，我们需要新实例化一个ListNode类node作为一个新的节点，此时的node.next

里面存储

插入前：

插入后：

 //头插
    public void addFirst(int val){
        ListNode node=new ListNode(val);
        node.next=head;
        head=node;
    }

6、尾部插入方法： 

尾部插入方法分为两种情况讨论：链表head为空or链表head不为空 

首先实例化一个节点类的对象node

1、当链表的head为空，我们只需要将head=node就行

2、当链表的head不为空，先找到尾节点，再将尾节点的next赋值为node

 //尾插
    public void addLast(int val){
        ListNode node=new ListNode(val);
      //如果head为空
        if(head==null){
            head=node;
            return;
        }


      //当head不为空
        ListNode cur=head;
        //找到尾节点
        while(cur.next!=null){
            cur=cur.next;
        }
        cur.next=node;
    }

7、任意位置插入方法： 

   相对于头部插入和尾部插入，这个任意位置插入的方法实现起来比较复杂，原因是，它自己本身也包含了头部插入和尾部插入功能！并且在此之上，还可以插入除了头部和尾部之间的任意位置！ 

   首先，我们要弄清楚的一点是，链表本身不像顺序表，它是没有下标这个概念的，但是为了实现这个功能，我们可以人为地认为链表是有下标（index）的！

如图：

那么我们可以将其分为几种情况：

1、index==0，这时相当于头部插入

2、index==size（size表示链表节点的个数），这时相当于尾部插入

3、0<index<size，插入除头部和尾部的任意中间位置

4、index<0或index>size，下标不合法

1、index==0 和  2、index==size

这个时候调用头部插入方法和尾部插入方法即可

        //index==0,相当于头插
        if(index==0){
            addFirst(val);
            return;
        }

        //index=size,相当于尾插
        if(index==size()){
            addLast(val);
            return;
        }

3、0<index<size 

这种情况下，我们分为两步走：

第一步：找到index位置的前一个位置，

先定义一个cur==head，然后移动cur，使cur找到index位置的前一个位置

  //找到index的前一个位置的方法：
    private ListNode findIndexSubOne(int index){
        ListNode cur=head;
        int count=0;
        while(count!=index-1){
            cur=cur.next;
            count++;
        }
        return cur;
    }

第二步：连接节点 

连接节点只需要修改两个东西，以图为例子：

一个是新节点node的next，要存入原下标为2的节点的地址

一个是下标为1的节点的next，要修改为node的地址

修改之后：

 //0<index<size
         if(index>0&&index<size()){
            ListNode node=new ListNode(val);
            ListNode cur=findIndexSubOne(index);
            node.next=cur.next;
            cur.next=node;
        }

 4、index<0或index>size(index不合法)

这种情况下，我们可以在插入前检查下标，如果不合法，那就抛出异常！

首先新建一个类，定义一个异常类：

public class IndexNotLeaglException extends RuntimeException{
    IndexNotLeaglException(){

    }
    IndexNotLeaglException(String msg){
        super(msg);
    }
}

然后在MySingleLinkedList类中实现一个检查下标的方法：

//检查index是否合法
    private void checkIndex(int index){
        if(index<0||index>size()){
            throw new IndexNotLeaglException("index不合法！");
        }
    }

接下来就使用try……catch语句使用该异常类 

 

任意插入方法的全部代码  

//任意位置插入的方法：
    public void add(int index,int val){
        //检查index是否合法
        try{
            checkIndex(index);
        }catch (IndexNotLeaglException e){
            e.printStackTrace();
        }

        //index==0,相当于头插
        if(index==0){
            addFirst(val);
            return;
        }

        //index=size,相当于尾插
        if(index==size()){
            addLast(val);
            return;
        }

        //0<index<size
         if(index>0&&index<size()){
            ListNode node=new ListNode(val);
            ListNode cur=findIndexSubOne(index);
            node.next=cur.next;
            cur.next=node;
        }

        }


    //找到index的前一个位置的方法：
    private ListNode findIndexSubOne(int index){
        ListNode cur=head;
        int count=0;
        while(count!=index-1){
            cur=cur.next;
            count++;
        }
        return cur;
    }


    //检查index是否合法
    private void checkIndex(int index){
        if(index<0||index>size()){
            throw new IndexNotLeaglException("index不合法！");
        }
    }
}

新创建的异常类型： 

8、查找是否包含关键字key的方法：

查找链表中的每一个节点，如果链表中存在key，返回true，不存在key，返回false 

 //查找是否包含某个关键字key的方法：
    public boolean contains(int key){
        ListNode cur=head;
        while(cur!=null) {
            if(cur.val==key){
                return true;
            }
            cur=cur.next;
        }
        return false;
    }

9、删除第一次出现关键字为key的节点 的方法：

   删除指定元素的节点分为2种情况：

1、删除的元素在头节点：

这种情况比较简单：只需要将链表的头修改为下一个链表的地址即可！

另外，如果head==null，不执行任何操作，直接return

 //1、删除头节点
        if(head==null){
            return;
        }
        if(head.val==key){
            head=head.next;
            return;
        }

2、要删除的元素不在头节点： 

如果要删除指定元素所在的节点，我们可以先定义一个cur，让它找到要删除节点的前一个节点！

   用cur.next节点的val来判断，cur的下一个节点存储的元素是不是我们要找的元素key，如果是，那么此时的cur正指向要删除节点的前一个节点！

   注意，此时while循环的判断条件应该是（cur.next!=null)而不是（cur!=null)!

//先找到要删除的前一个节点
       ListNode cur=head;
       while(cur.next!=null){
           if(cur.next.val==key){
               break;
           }
           cur=cur.next;
       }
       //删除该节点
        cur.next=cur.next.next;
    }

让我们看看二者的区别：

1、cur!=null

当cur指向该链表的最后一个节点，由于cur！=null，因此进入循环。

我们就会发现，在循环体语句cur.next.val==key会报错！因为cur.next为null，因此也不会有cur.next.next(相当于null.next)

2 、cur.next!=null

当cur指向倒数第二个节点，上述的语法不会报错！

10、删除链表中相同的元素的方法：


    //去除链表中所有相同的关键字
    public void removeAllKey(int key){

        if(head==null){
            return;
        }
        //1、先去除头节点以外的与key相同值的节点
        ListNode prev=head;//cur的前驱节点
        ListNode cur=head.next;//寻找要去除的节点

        //判断并且删除节点
        while(cur!=null){
            if(cur.val==key){
                prev.next=cur.next;
                cur=cur.next;
            }else{
                prev=cur;
                cur=cur.next;
            }
        }

        //2、判断头节点存储的内容是否为key
        if(head.val==key){
            head=head.next;
        }
    }

wu_yi_min
关注
  • 26
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java排序链表
LX__dream的博客
05-28 2929
剑指offer 148.排序链表 解题思路: 由时间复杂度O(nlogn)知道我们可以使用归并排序 归并排序经常会出现在合并两个有序链表这样类似的题中 定义fast指针和slow指针, 利用fast和slow将链表从中点分为两个链表 ① 对应操作: slow = slow.next; fast = fast.next.next; 此时slow指针刚好停在链表的中点 ② 将链表从中间断开的操作: slow.next = null; ③ 此时左右两个断开的链表的第一个节点分别为head和tmp 对.
javalist源码-LinkedList-in-Java:链表的Java源代码实现
05-19
在Java编程语言中，`LinkedList`是`List`接口的一个实现，它提供了链表数据结构的支持。`LinkedList`类在`java.util`包中定义，主要用于存储和操作有序的元素集合。这个类允许我们在列表的任何位置进行插入和删除...
java:链表排序
sinat_35803474的博客
04-18 3483
题目描述：Sort a linked list using insertion sort. 使用插入排序对链表进行排序 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { *
Java算法进阶(一):链表
Justin_Andyson的博客
04-11 936
Java算法链表的深究
Java实现链表
m0_64368538的博客
12-12 3413
新手用Java写链表
JAVA——链表
热门推荐
qq_69133469的博客
04-23 2万+
一、链表概念及结构 链表：链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。如下图：（通俗的说：就是由一个个节点组成，这些节点逻辑上连续，物理上不连续） 类比火车： singleLinkedList ——火车车次（一整个火车or哪趟火车） Node——车厢，具体储存元素的类，每个单链表的节点就是Node的一个对象 Node.head ；——当前链表的头节点（只要知道头节点就可以此访问链表中的所有节点） int size ；——当前链表的长度（节点个.
Java数据结构：链表
接受自己的普通，然后拼尽全力去与众不同
08-09 1524
1. 概述 链表是一种数据结构，在内存中通过节点记录内存地址而相互链接形成一条链的储存方式。链表的插入和删除都比较快，缺点是查找比较慢。除非需要频繁的通过下标来随机访问数据，否则在很多使用数组的地方都可以用链表代替。相比数组而言，链表在内存中不需要连续的区域，只需要每一个节点都能够记录下一个节点的内存地址，通过引用进行查找，因此链表增删操作时间消耗很小，而查找遍历时间消耗很大。 2. 链表的分...
Java中的链表
weixin_52758364的博客
12-09 3394
以实践为线索，逐步深入数据结构和算法，提升编程能力和思维能力。
java实现链表
weixin_46972127的博客
03-18 5327
1、什么是链表 链表是一种数据结构，和数组同级别。Java中我们使用的LInkedList，其实现原理为链表，而ArrayList其实现原理为数组。链表在插入和删除时优势明显。 单链表是一种线性表，实际上由节点（Node）组成，可以把单链表想象成为一列火车，而组成单链表的每个节点想象成为一节车厢。节点中存储了节点的值（data）以及指向下一个节点的指针（Next）。 2、单链表的实现（增删查改） package LinkedList; // 车厢类 class Node { // 存储
Java手写链表
qq_45464560的博客
09-28 2079
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V73ZFeSh-1632464808641)(https://img-mid.csdnimg.cn/release/static/image/mid/ask/081087464236187.jpg “=600 #left”)]
java反转链表
wrywry0813的博客
11-13 603
给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。链表的反转中，我们可以用到栈先进后出的特点，将原链表中的结点按顺序放入栈中，之后将栈中的元素取出，连接成链表。要求：空间复杂度 O(1)O(1) ，时间复杂度 O(n)O(n)。经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。我们在原链表中更改结点之间的指向，即可完成对链表的反转。数据范围： 0
LinkedList:链表
07-03
本篇文章将深入探讨链表的概念、Java中的LinkedList类以及其常用方法。 ### 链表概念 链表不同于数组，它不连续存储元素。每个元素（节点）包含两部分：数据和指向下一个节点的引用。这种存储方式使得在链表中插入...
LinkedLists:链表操作
06-25
1. **双向链表**：Java中的LinkedList是双向链表，每个节点都有前驱和后继节点，这使得双向操作更加方便。 2. **队列操作**：由于其特性，LinkedList可以用作队列，`offer()`和`poll()`分别用于入队和出队。 3. **栈...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 269
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1058
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 117
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 582
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
Java数据结构：链表与数组实现栈的深度解析
"Java数据结构篇-链表与数组实现栈深入理解栈的基本概念及操作，探讨了如何用链表和数组在Java中构建栈，强调了数据结构在编程中的重要性。" 在计算机科学中，数据结构是设计和实现算法的基础，它涉及如何有效地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值