Java中的链表实现介绍

news2024/9/23 21:27:43

Java中的链表实现介绍

学习数据结构的的链表和树时，会遇到节点（node）和链表（linked list）这两个术语，节点是处理数据结构的链表和树的基础。节点是一种数据元素，包括两个部分：一个是实际需要用到的数据；另一个存储下一个节点位置【用数据结构中的术语，称为数据域（Data field） 与 指针域（pointer field）】。链表是一系列节点串联形成的数据结构，链表中的元素在内存中并不是连续的。

本文仅以单链表为例介绍。

单链表只有一个指向其他节点的变量，也就是在这种类型的数据结构中，任何两个数据元素之间只有一个链接，参见下图：

链表的操作包括了创建、删除、插入、输出等。

创建就是空间的分配，将头、尾指针及链表结点个数等初始化。删除和插入根据被操作元素的位置可以细分为头删除（插入），尾删除（插入），中间删除（插入）。

插入操作

头插入实际上是增加一个新节点，然后把新增加的结点指针指向原来头指针指向的元素，再把头指针指向新增的节点。

尾插入也是增加一个新节点，该节点指针置为null，然后把原尾结点指针指向新增加的节点，最后把尾指针指向新增加的节点即可。

中间插入稍复杂，首先增加一个节点，然后新增节点的指针指向插入位置的后一个节点，把插入位置的前一个节点指针指向新插入节点即可。

删除操作

删除头元素时，先将头指针指向下一个节点，然后把原头结点的指针置空即可。

删除尾元素时，首先找到链表倒数第2个元素，然后把尾指针指向这个元素，接着把原倒数第2个元素的指针置空。

删除中间元素相对复杂一些，首先将要删除的节点的前一个节点指针指向要删除的节点的下一个节点，然后把要删除节点的指针置空。

上面提到是单链表最基本的操作，除此之外还有其它操作不多说了。下面给出代码示例。

下面介绍两种实现方式。

一、使用Java.util 包的LinkedList类实现

JAVA提供的LinkedList类简要介绍

JAVA提供的LinkedList类，它也可以被当作堆栈、队列或双端队列进行操作。

LinkedList 实现 List 接口，能进行列表的相关操作。

LinkedList 实现了 Queue 接口，可作为队列使用。

LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。

LinkedList官方文档LinkedList (Java Platform SE 8 )

LinkedList 类位于 java.util 包中，使用前需要引入它，语法格式如下：

import java.util.LinkedList;

常用的方法（Method）及说明

public boolean add(E e)

链表末尾添加元素，返回是否成功，成功为 true，失败为 false。

public void add(int index, E element)

向指定位置插入元素。

public boolean addAll(Collection c)

将一个集合的所有元素添加到链表后面，返回是否成功，成功为 true，失败为 false。

public boolean addAll(int index, Collection c)

将一个集合的所有元素添加到链表的指定位置后面，返回是否成功，成功为 true，失败为 false。

public void addFirst(E e)

元素添加到头部。

public void addLast(E e)

元素添加到尾部。

public boolean offer(E e)

向链表末尾添加元素，返回是否成功，成功为 true，失败为 false。

public boolean offerFirst(E e)

头部插入元素，返回是否成功，成功为 true，失败为 false。

public boolean offerLast(E e)

尾部插入元素，返回是否成功，成功为 true，失败为 false。

public void clear()

清空链表。

public E removeFirst()

删除并返回第一个元素。

public E removeLast()

删除并返回最后一个元素。

public boolean remove(Object o)

删除某一元素，返回是否成功，成功为 true，失败为 false。

public E remove(int index)

删除指定位置的元素。

public E poll()

删除并返回第一个元素。

public E remove()

删除并返回第一个元素。

public boolean contains(Object o)

判断是否含有某一元素。

public E get(int index)

返回指定位置的元素。

public E getFirst()

返回第一个元素。

public E getLast()

返回最后一个元素。

public int indexOf(Object o)

查找指定元素从前往后第一次出现的索引。

public int lastIndexOf(Object o)

查找指定元素最后一次出现的索引。

public E peek()

返回第一个元素。

public E element()

返回第一个元素。

public E peekFirst()

返回头部元素。

public E peekLast()

返回尾部元素。

public E set(int index, E element)

设置指定位置的元素。

public Object clone()

克隆该列表。

public Iterator descendingIterator()

返回倒序迭代器。

public int size()

返回链表元素个数。

public ListIterator listIterator(int index)

返回从指定位置开始到末尾的迭代器。

public Object[] toArray()

返回一个由链表元素组成的数组。

public T[] toArray(T[] a)

返回一个由链表元素转换类型而成的数组。

 

JAVA提供的LinkedList类使用示例（来源https://www.cnblogs.com/jbclown/p/16024181.html ），源码如下：

import java.util.LinkedList; // 引入 LinkedList 类
public class LinkedListTest {
    public static void main(String[] args) {
        //引入LinkedList类
        LinkedList<String> lList = new LinkedList<String>();

        //添加元素
        lList.add("hello");
        lList.add("world");
        lList.add("java");
        lList.add("LinkedList");

        //链表元素个数
        System.out.println(lList.size());
        //getFirst()方法获取头部元素
        System.out.println(lList.getFirst()); //hello
        //addFirst() 在头部添加元素
        lList.addFirst("the");  //[the, hello, world, java, LinkedList]
        System.out.println(lList);
        //addLast() 在尾部添加元素
        lList.addLast("ArrayList"); //[the, hello, world, java, LinkedList, ArrayList]
        System.out.println(lList);
        // removeFirst() 移除头部元素
        lList.removeFirst();  // [hello, world, java, LinkedList, ArrayList]
        // set(int index, E element) 指定元素替换指定位置的元素
        lList.set(1,"the"); //[hello, the, java, LinkedList, ArrayList]
        System.out.println(lList);
        // add( int index,E element) 指定位置插入元素
        lList.add(2,"world"); //[hello, the, world, java, LinkedList, ArrayList]
        System.out.println(lList);
        // for-each 迭代元素
        System.out.println("for-each 迭代元素:");
        for (String s : lList){
            System.out.println(s);
        }
    }
}

输出：

4
hello
[the, hello, world, java, LinkedList]
[the, hello, world, java, LinkedList, ArrayList]
[hello, the, java, LinkedList, ArrayList]
[hello, the, world, java, LinkedList, ArrayList]
for-each 迭代元素:
hello
the
world
java
LinkedList
ArrayList
 

二、自定义实现类实现

我们也可以自定义实现类似功能，请看下面的介绍。

Java单向链表的代码实现（java单向链表的模拟实现_java模拟单向链表_忆兮513的博客-CSDN博客 ）

由链表类MyList、测试类main和异常类IndexOutOfException组成

链表类MyList源码：

public class MyList {
 
    public static class ListNode{
      int val;
      public ListNode next;
      public ListNode(int val){
            this.val=val;
        }
    };
 
    public ListNode head;
 
    public void createList(){
        ListNode ListNode1=new ListNode(45);
        ListNode ListNode2=new ListNode(35);
        ListNode ListNode3=new ListNode(55);
        ListNode ListNode4=new ListNode(34);
 
        ListNode1.next=ListNode2;
        ListNode2.next=ListNode3;
        ListNode3.next=ListNode4;
        ListNode4.next=null;
 
        this.head=ListNode1;
    }
 
    public void display(){
        /**
         * 这样会把head弄成空
         */
        /*while(head!=null){
            System.out.print(head.val+" ");
            head=head.next;
        }*/
        ListNode cur=head;
        while(cur!=null){
            System.out.print(cur.val+" ");
            cur=cur.next;
        }        
    }
 
    //头插法
    public void addFirst(int data) {
        ListNode node=new ListNode(data);
        node.next=head;
        head=node; 
    }
    //尾插法
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if (head == null) {
            head = node;
        } else {
            ListNode cur = head;
            while (cur.next != null) {
                cur = cur.next;
            }
            cur.next = node;
        }
    }
 
    //检查index是否合法
    private void checkindex(int index){
        if(index<0||index>size()){
            throw new IndexOutOfException("位置不合法，请重新输入：");
        }
    }
    //找到index-1位置的节点
    private ListNode FindIndexNode(int index){
        ListNode cur=head;
        while (index-1!=0){
            cur=cur.next;
            index--;
        }
        return cur;
    }
 
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data){
        checkindex(index);
        if(index==0){
            addFirst(data);
            return;
        }
        else if(index==size()){
            addLast(data);
            return;
        }
        else {
            ListNode node = new ListNode(data);
            ListNode cur=FindIndexNode(index);
            node.next=cur.next;
            cur.next=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=head;
        while (cur.next!=null) {
            if (cur.next.val == key) {
                cur.next = cur.next.next;
                return;
            }
            cur=cur.next;
        }
    }
    //删除所有值为key的节点
    public void removeAllKey(int key){
        ListNode cur=head.next;
        ListNode pre=head;
        while(cur!=null){
            if(cur.val==key){
                pre.next=cur.next;
                cur=cur.next;
            }else{
            pre=cur;
            cur=cur.next;
            }
        }
        if(head.val==key){
            head=head.next;
        }
    }
    //得到单链表的长度
    public int size(){
        int count=0;
        ListNode cur=head;
        while(cur!=null){
            cur=cur.next;
            count++;
        }
        return count;
    }
 
    public void clear(){
        ListNode cur=head;
        ListNode curNext=null;
        while(cur!=null){
            curNext=cur.next;
            cur.next=null;
            cur=curNext;
        }
        head=null;
    }
 
}

异常类IndexOutOfException源码：

public class IndexOutOfException extends RuntimeException{
    public IndexOutOfException(){
 
    }
 
    public IndexOutOfException(String mes){
        super(mes);
    }
}

 测试类main源码：

public class main {
    public static void main(String[] args) {
        MyList list=new MyList();
        list.createList();
        list.display();
        System.out.println(list.contains(45));
        System.out.println(list.size());
        list.addFirst(99);
        list.display();
        System.out.println();//换行
        list.addLast(999);
        list.display();
        System.out.println();
        list.addIndex(1,50);
        list.display();
        System.out.println();
 
        list.removeAllKey(45);
        list.display();
 
        list.clear();
        list.display();
    }
}

运行结果：

45 35 55 34 true
4
99 45 35 55 34 
99 45 35 55 34 999 
99 50 45 35 55 34 999 
99 50 35 55 34 999
 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/355409.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

pytest总结

pytest总结

这里写目录标题一、pytest的命名规则二、界面化配置符合命名规则的方法前面会有运行标记三、pytest的用例结构三部分组成四、pytest的用例断言断言写法&#xff1a;五、pytest测试框架结构六、pytest参数化用例1、pytest参数化实现方式2、单参数&#xff1a;每一条测试数据都会…
阅读更多...
第五十七章 树状数组（二）

第五十七章 树状数组（二）

第五十七章 树状数组&#xff08;二&#xff09;一、差分的缺陷二、树状数组与差分三、例题题目描述输入格式输出格式样例 #1样例输入 #1样例输出 #1提示样例 1 解释&#xff1a;数据规模与约定代码一、差分的缺陷 差分的作用是能够在O(1)的时间内给一段区间加上相同的数字&am…
阅读更多...
【计算机网络】数据链路层(上)

【计算机网络】数据链路层(上)

文章目录数据链路层概述封装成帧透明传输差错检测奇偶校验循环冗余校验CRC可靠传输可靠传输基本概念实现机制 — 停止-等待协议实现机制 — 回退N帧协议实现机制 — 选择重传协议点对点协议PPP数据链路层概述 首先我蛮来看看数据链路层在网络体系结构中的地位。如图所示主机h1…
阅读更多...
key的作用原理与列表的遍历、追加、搜索、排序

key的作用原理与列表的遍历、追加、搜索、排序

目录 一、key的作用原理 二、实现列表遍历并对在列表最前方进行追加元素 三、实现列表过滤搜索 1、用computed计算属性来实现 2、用watch监听输入值的变化来实现 四、按年龄排序输出列表 一、key的作用原理 1. 虚拟DOM中key的作用&#xff1a; key是虚拟DOM对象的标识&a…
阅读更多...
博彩公司 BetMGM 发生数据泄露，“赌徒”面临网络风险

博彩公司 BetMGM 发生数据泄露，“赌徒”面临网络风险

Bleeping Computer 网站披露&#xff0c;著名体育博彩公司 BetMGM 发生一起数据泄露事件&#xff0c;一名威胁攻击者成功窃取其大量用户个人信息。 据悉&#xff0c;BetMGM 数据泄漏事件中&#xff0c;攻击者盗取了包括用户姓名、联系信息&#xff08;如邮政地址、电子邮件地址…
阅读更多...
Unity如何实现3D物体拆解组装

Unity如何实现3D物体拆解组装

一.前言 最近有一个需求，是做一个发动机的拆卸和安装功能，其实是一个很简单的功能，但是其中有一个点我觉的非常有意思，就是拖拽组装时，物体如何精准拖到目标位置，思路有了，但是我一直找不到实现方式，早晨刷牙时无意间想到了叉乘，我才有了解决方案。就凭这一次的灵光乍…
阅读更多...
AutoJs7、8版本快速接通vscode进行调试脚本

AutoJs7、8版本快速接通vscode进行调试脚本

AutoJs7、8版本快速接通vscode进行调试脚本 作者：虚坏叔叔 博客：https://xuhss.com 早餐店不会开到晚上，想吃的人早就来了！😄 # AutoJs7、8快速接通vscode进行调试脚本一、下载AutoJs并安装 https://download.csdn.net/download/huangbangqing12/87449177 下载完成后，…
阅读更多...
【图神经网络】图拉普拉斯滤波器如何实现全通、低通、高通滤波

【图神经网络】图拉普拉斯滤波器如何实现全通、低通、高通滤波

【图神经网络】图拉普拉斯滤波器如何实现全通、低通、高通滤波 文章目录【图神经网络】图拉普拉斯滤波器如何实现全通、低通、高通滤波1. 前言2. 符号说明3. 三种滤波3.1 全通滤波3.2 低通滤波3.2.1 平滑信号分析3.2.2 广义拉普拉斯平滑滤波器3.3 高通滤波4. 总结1. 前言 GCN&…
阅读更多...
同步互斥与通信

同步互斥与通信

我们可以把多任务系统当作一个团队&#xff0c;里面的每一个任务都相当于团队里的一个人。团队成员之间要协调工作进度&#xff08;同步&#xff09;、争用会议室&#xff08;互斥&#xff09;、沟通&#xff08;通信&#xff09;。多任务系统所涉及的概念&#xff0c;都可以在…
阅读更多...
Spring之事务底层源码解析

Spring之事务底层源码解析

Spring之事务底层源码解析 1、EnableTransactionManagement工作原理 开启 Spring 事务本质上就是增加了一个 Advisor&#xff0c;当我们使用 EnableTransactionManagement 注解来开启 Spring 事务时&#xff0c;该注解代理的功能就是向 Spring 容器中添加了两个 Bean&#xf…
阅读更多...
【算法基础】并查集⭐⭐⭐⭐⭐【思路巧，代码短，面试常考】

【算法基础】并查集⭐⭐⭐⭐⭐【思路巧，代码短，面试常考】

并查集，在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。这一类问题近几年来反复出现在信息学的国际国内赛题中。其特点是看似并不复杂，但数据量…
阅读更多...
二叉树的相关列题！！

二叉树的相关列题！！

对于二叉树&#xff0c;很难&#xff0c;很难&#xff01;笔者也是感觉很难&#xff01;虽然能听懂课程&#xff0c;但是&#xff0c;对于大部分的练习题并不能做出来&#xff01;所以感觉很尴尬&#xff01;&#xff01;因此&#xff0c;笔者经过先前的那篇博客&#xff0c;已…
阅读更多...
Windows下编译安装Redis

Windows下编译安装Redis

Windows下安装Redis1.下载cygwin2.安装cygwin3.下载Redis4.编译Redis5.运行redis6.报错&#xff1a;继上次Windows下安装MySQL后&#xff0c;今天安装Redis发现也复杂许多&#xff0c;github上有几个仓库似乎提供了windows一键安装版&#xff0c;但是到 5.0版本就不更新了……所…
阅读更多...
python机器学习

python机器学习

机器学习可分为两大类&#xff0c;分别为监督学习与非监督学习 监督学习 监督学习是机器学习的类型&#xff0c;其中机器使用“标记好”的训练数据进行训练&#xff0c;并基于该数据&#xff0c;机器预测输出。标记的数据意味着一些输入数据已经用正确的输出标记。 在监督学习…
阅读更多...
设计模式之策略模式与责任链模式详解和应用

设计模式之策略模式与责任链模式详解和应用

目录1.策略模式1.1 目标1.2.内容定位1.3.定义1.4.应用场景1.5.促销优惠业务场景1.6 用策略模式实现选择支付方式的业务场景1.7 策略模式在框架源码中的体现1.8 策略模式的优缺点2 责任链模式2.1 责任链楼式的应用场景2.2 利用责任链模式进行数据校验拦截2.3 责任链模式和建造者…
阅读更多...
实战打靶集锦-006-Stapler

实战打靶集锦-006-Stapler

**写在前面&#xff1a;**记录博主的一次打靶经历。 目录1. 主机发现2. 端口发现3. 服务枚举4. 服务探查4.1 FTP探查4.1.1 匿名登录4.1.2 Elly用户4.1.3 John用户4.1.4 EXP搜索4.2 dnsmasq探查4.2.1 基础信息获取4.2.2 EXP搜索4.3 WEB应用探查4.3.1 浏览器访问4.3.2 目录扫描4.…
阅读更多...
Nacos超简单-管理配置文件

Nacos超简单-管理配置文件

优点理论什么的就不说了&#xff0c;按照流程开始配配置吧。登录Centos&#xff0c;启动Naocs&#xff0c;使用sh /data/soft/restart.sh将自动启动Nacos。访问&#xff1a;http://192.168.101.65:8848/nacos/账号密码&#xff1a;nacos/nacos分为两部分&#xff0c;第一部分准…
阅读更多...
【RabbitMQ】Windows 安装 RabbitMQ

【RabbitMQ】Windows 安装 RabbitMQ

文章目录工具下载Eralng 安装与配置RabbitMQ 安装工具下载 RabbitMQ 3.7.4版本 网盘链接&#xff1a;https://pan.baidu.com/s/1pO6Q8fUbiMrtclpq2KqVVQ?pwdgf29 提取码&#xff1a;gf29 Eralng 网盘链接&#xff1a;https://pan.baidu.com/s/1irf8fgK77k8T9QzsIRwa7g?pwd9…
阅读更多...
广度优先搜索(BFS)-蓝桥杯

广度优先搜索(BFS)-蓝桥杯

一、BFS搜索的原理BFS搜索的原理&#xff1a;“逐层扩散”&#xff0c;从起点出发&#xff0c;按层次从近到远&#xff0c;逐层先后搜索。编码&#xff1a;用队列实现。应用&#xff1a;BFS一般用于求最短路径问题&#xff0c;BFS的特点是逐层搜索&#xff0c;先搜到的层离起点…
阅读更多...
Prometheus 记录规则和警报规则

Prometheus 记录规则和警报规则

前提环境&#xff1a; Docker环境 涉及参考文档&#xff1a; Prometheus 录制规则Prometheus 警报规则 语法检查规则 promtool check rules /path/to/example.rules.yml一&#xff1a;录制规则语法 groups 语法&#xff1a; groups:[ - <rule_group> ]rule_group…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023