Java实现单链表（步骤详解+源码）

最新推荐文章于 2024-03-29 19:52:29 发布
最新推荐文章于 2024-03-29 19:52:29 发布
阅读量6.6k 收藏 74
点赞数 11
分类专栏： 数据结构与算法 文章标签： java 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48592827/article/details/127314141
版权

Java实现单链表（附源码）

文章目录

前言

此文章主要实现单链表的基本操作。
我也是一位学习者，如果有任何问题，欢迎私信交流学习！

提示：以下是本篇文章正文内容，下面案例可供参考

一、学习目的

  1. 理解线性表的逻辑结构；
  2. 理解单链表的存储结构特点，掌握单链表的存储分配要点；
  3. 掌握单链表的基本操作及实现，并能正确分析其时间复杂度；

二、主要内容

1.定义单链表的存储结构

首先我们需要定义两个类：结点类（Node）、单链表（SingleLinkList）
结点类主要用于存储数据和下一个结点的地址
单链表主要用于存储结点以及基本操作

代码如下（示例）：

结点类（Node）

public class LinkListNode {

    private Integer data; // 结点的数据域

    private LinkListNode next; // 下一个结点
}

单链表（SingleLinkList）

public class SingleLinkList {

    private LinkListNode head;//定义单链表的头结点

    private int length;//用来记录单链表的长度

}

2.单链表的基本操作及实现

  1. 初始化单链表（无参和有参）
    我对链表的初始化有点不太理解，因为存在有参和无参构造，但是在java语言中本来就存在无参构造；
    这里就强行解释一波：
    · 无参构造理解为初始化单链表（包含头结点）
    · 有参构造理解为初始化单链表和首元结点（包含头结点和首元结点）
	/**
     * 单链表的初始化 init() 无参
     */
    public SingleLinkList(){
        this.head = new LinkListNode();
    }

    /**
     * 单链表的初始化 init() 有参
     * */
    public SingleLinkList(Integer data,LinkListNode next){
        this.head = new LinkListNode();
        LinkListNode node = new LinkListNode();
        node.setData(data);
        node.setNext(next);
        head.setNext(node);
    }
  1. 求单链表长度
    在我的单链表类中属性包含了长度，这样就可以通过空间换时间，当需要获取单链表的长度时，可以直接访问属性而无需遍历单链表 。
	/**
     * 求单链表长度
     */
    public int getLength(){
        return length;
    }
  1. 新增：默认在最后插入一个数据元素
    创建一个p指针，用于遍历单链表找到最后一个元素，然后将新结点的地址赋给最后一个结点的下一个地址。
    这种情况下是这样的：
    · 单链表：1，2，3，4，5
    · 新增：插入“99”
    · 结果：1，2，3，4，5，99
	/**
     * 新增：默认在最后插入一个数据元素；
     */
    public LinkListNode insert(Integer data){
        LinkListNode newNode = new LinkListNode(data);
        LinkListNode p = head;
        while (p.getNext()!=null){
            p = p.getNext();
        }
        p.setNext(newNode);
        length++;
        return newNode;
    }
  1. 新增：在位置i插入一个数据元素
    这个要首先判断这个位置i是否大于了单链表的长度，比如此时单链表的长度为4，输入的位置i为6，显然位置5都还没有结点，所以我默认将这个新结点添加在单链表的末尾；
    这种情况下是这样的：
    · 单链表：1，2，3，4，5
    · 新增：在第3个位置插入“99”
    · 结果：1，99，2，3，4，5
	/**
     * 新增：在位置i插入一个数据元素；
     */
    public void insertByIndex(int index,Integer data){
        // 如果位置i大于了单链表的长度 或者 位置不合理 则直接将新结点添加到最后
        if(index>length||index-1<0){
            insert(data);
            return;
        }
        index--;
        // 将指针p指向首元结点
        LinkListNode p = head;
        while (index!=0){
            p=p.getNext();
            index--;
        }
        LinkListNode newNode = new LinkListNode(data,p.getNext());
        p.setNext(newNode);
        length++;
    }
  1. 查找：按位置查找
    第一步：判定输入的位置是否大于单链表长度（大于则直接返回null）
    第二步：通过p指针移动到指定的位置，获取数据元素
	/**
     * 查找：按位置查找
     */
    public Integer getByIndex(int index){
        // 如果查找的元素大于了单链表的长度则返回null
        if(index>length){
            return null;
        }
        // 将指针p指向头结点
        LinkListNode p = head;
        while (index!=0){
            p=p.getNext();
            index--;
        }
        return p.getData();
    }
  1. 查找：按值查找
    通过移动p指针，取出每一个结点的数据元素与输入的值进行对比，如果发现数据匹配的结点，就返回结点位置；如果单链表都遍历完了还没有找到就返回0，因为我的单链表位置是从1开始计算的，返回0就表示未找到。
	/**
     * 查找：按值查找
     */
    public int getByData(Integer data){
        // 将指针p指向首元结点
        LinkListNode p = head;
        int index = 0;
        while (p.getNext()!=null){
            p=p.getNext();
            index++;
            if(p.getData().equals(data)){
                return index;
            }
        }
        if(index==length&&!p.getData().equals(data)){
            return 0;
        }
        return index;
    }
  1. 查找：遍历单链表
    创建p结点做为指针，遍历单链表。
 	/**
     * 查找：遍历单链表
     */
    public void traverse(){
        LinkListNode p = head;
        while (p.getNext()!=null){
            p = p.getNext();
            System.out.println("结点值："+p.getData());
        }
    }
  1. 删除：按位置i删除数据元素
    第一步：判定位置i是否大于单链表的长度（是就返回null）
    第二步：将p指针移动到被删除元素的前一个位置，主要是为了断开删除元素的连接，连接下一个结点的地址。
	 /**
     * 删除：按位置i删除数据元素；
     */
    public Integer deleteByIndex(int index){
        // 如果位置i大于了单链表的长度则返回null
        if(index>length||index-1<0){
            return null;
        }
        // 提前将index-- 是为了将p指针移到被删除元素的前一个位置
        index--;
        // 将指针p指向头结点
        LinkListNode p = head;
        while (index!=0){
            p=p.getNext();
            index--;
        }
        int res = p.getNext().getData();
        p.setNext(p.getNext().getNext());
        length--;
        return res;
    }
  1. 合并链表
    直接将第二个链表的首元结点的地址赋值给第一个链表的最后一个结点的地址域。
	/**
     * 合并链表
     */
    public void marge(SingleLinkList singleLinkList){
        LinkListNode p = head;
        length=length+singleLinkList.length;
        while (p.getNext()!=null){
            p = p.getNext();
        }
        p.setNext(singleLinkList.head.getNext());
    }

3.完整代码

结点类：LinkListNode

package experiment_01;

public class LinkListNode {

    private Integer data; // 结点的数据域

    private LinkListNode next; // 下一个结点

    public LinkListNode(){
    }

    public LinkListNode(Integer data){
        this.data = data;
        this.next = null;
    }
    public LinkListNode(Integer data,LinkListNode next){
        this.data = data;
        this.next = next;
    }

    public Integer getData() {
        return data;
    }

    public void setData(Integer data) {
        this.data = data;
    }

    public LinkListNode getNext() {
        return next;
    }

    public void setNext(LinkListNode next) {
        this.next = next;
    }


}

单链表类：SingleLinkList

public class SingleLinkList {

    private LinkListNode head;//定义单链表的头结点

    private int length;//用来记录单链表的长度

    /**
     * 单链表的初始化 init() 无参
     */
    public SingleLinkList(){
        this.head = new LinkListNode();
    }

    /**
     * 单链表的初始化 init() 有参
     * */
    public SingleLinkList(Integer data,LinkListNode next){
        this.head = new LinkListNode();
        LinkListNode node = new LinkListNode();
        node.setData(data);
        node.setNext(next);
        head.setNext(node);
    }

    /**
     * 求单链表长度
     */
    public int getLength(){
        return length;
    }

    /**
     * 新增：默认在最后插入一个数据元素；
     */
    public LinkListNode insert(Integer data){
        LinkListNode newNode = new LinkListNode(data);
        LinkListNode p = head;
        while (p.getNext()!=null){
            p = p.getNext();
        }
        p.setNext(newNode);
        length++;
        return newNode;
    }

    /**
     * 新增：在位置i插入一个数据元素；
     */
    public void insertByIndex(int index,Integer data){
        // 如果位置i大于了单链表的长度 或者 位置不合理 则直接将新结点添加到最后
        if(index>length||index-1<0){
            insert(data);
            return;
        }
        index--;
        // 将指针p指向首元结点
        LinkListNode p = head;
        while (index!=0){
            p=p.getNext();
            index--;
        }
        LinkListNode newNode = new LinkListNode(data,p.getNext());
        p.setNext(newNode);
        length++;
    }

    /**
     * 查找：按位置查找
     */
    public Integer getByIndex(int index){
        // 如果查找的元素大于了单链表的长度则返回null
        if(index>length){
            return null;
        }
        // 将指针p指向头结点
        LinkListNode p = head;
        while (index!=0){
            p=p.getNext();
            index--;
        }
        return p.getData();
    }

    /**
     * 查找：按值查找
     */
    public int getByData(Integer data){
        // 将指针p指向首元结点
        LinkListNode p = head;
        int index = 0;
        while (p.getNext()!=null){
            p=p.getNext();
            index++;
            if(p.getData().equals(data)){
                return index;
            }
        }
        if(index==length&&!p.getData().equals(data)){
            return 0;
        }
        return index;
    }

    /**
     * 查找：遍历单链表
     */
    public void traverse(){
        LinkListNode p = head;
        while (p.getNext()!=null){
            p = p.getNext();
            System.out.println("结点值："+p.getData());
        }
    }

    /**
     * 删除：按位置i删除数据元素；
     */
    public Integer deleteByIndex(int index){
        // 如果位置i大于了单链表的长度则返回null
        if(index>length||index-1<0){
            return null;
        }
        // 提前将index-- 是为了将p指针移到被删除元素的前一个位置
        index--;
        // 将指针p指向头结点
        LinkListNode p = head;
        while (index!=0){
            p=p.getNext();
            index--;
        }
        int res = p.getNext().getData();
        p.setNext(p.getNext().getNext());
        length--;
        return res;
    }

    /**
     * 合并链表
     */
    public void marge(SingleLinkList singleLinkList){
        LinkListNode p = head;
        length=length+singleLinkList.length;
        while (p.getNext()!=null){
            p = p.getNext();
        }
        p.setNext(singleLinkList.head.getNext());
    }
}

测试类：LinkListTest

import java.util.Scanner;

public class LinkListTest {

    public static void main(String[] args){
        // 初始化单链表
        SingleLinkList singleLinkList = new SingleLinkList();

        // 在链表尾部新增结点
        singleLinkList.insert(15);
        singleLinkList.insert(16);
        singleLinkList.insert(17);
        singleLinkList.insert(18);

        Scanner scanner = new Scanner(System.in);
        int operation = 0;
        printList(singleLinkList);
        while (operation!=-1) {
            System.out.println("请选择一个操作：\n 1、遍历输出单链表 \n 2、根据位置查找结点的值 \n 3、根据值查找结点的位置 " +
                    "\n 4、在指定位置插入一个数据元素 \n 5、根据位置删除结点 \n 6、合并一个链表给你看看就行 \n 7、退出程序");
            operation = scanner.nextInt();
            switch (operation) {
                case 1:
                    // 遍历输出单链表
                    printList(singleLinkList);
                    break;
                case 2:
                    System.out.println("请问你要查找第几个结点的值？");
                    int index = scanner.nextInt();
                    System.out.println("第" + index + "个结点的值：" + singleLinkList.getByIndex(index));
                    break;
                case 3:
                    System.out.println("请问你要查找值为多少的结点位置？");
                    Integer data = scanner.nextInt();
                    System.out.println("值为" + data + "的结点位置：" + singleLinkList.getByData(data));
                    break;
                case 4:
                    System.out.println("请问你要在第几个位置插入结点？");
                    index = scanner.nextInt();
                    System.out.println("请问你要插入值为多少的结点？");
                    data = scanner.nextInt();
                    singleLinkList.insertByIndex(index, data);
                    break;
                case 5:
                    System.out.println("请问你要删除哪个位置的结点？");
                    index = scanner.nextInt();
                    singleLinkList.deleteByIndex(index);
                    break;
                case 6:
                    SingleLinkList singleLinkList2 = new SingleLinkList();
                    singleLinkList2.insert(1);
                    singleLinkList2.insert(2);
                    singleLinkList2.insert(3);
                    singleLinkList.marge(singleLinkList2);
                    break;
                default:
                    System.exit(0);
            }
        }
    }

    public static void printList(SingleLinkList singleLinkList){
        System.out.println("单链表的长度："+singleLinkList.getLength());
        singleLinkList.traverse();
    }

}

希望大家可以一次性运行成功喔！

总结

对不起了大家，今天没时间写了，下次补上。

PRINT！
关注
  • 11
    点赞
  • 踩
  • 74
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 14
    评论
专栏目录
JAVA数据结构之单链表
weixin_42145631的博客
08-20 315
链表是以节点的方式来存储,是链式存储每个节点包含 data 域， next 域：指向下一个节点.如图：发现链表的各个节点不一定是连续存储.链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定单链表(带头结点)逻辑结构示意图如下。
java 实现单链表逆转详解及实例代码
08-31
在这个Java实现中，我们有两个方法来完成这个任务：一个使用递归，另一个使用循环。 1. **递归实现单链表逆转**： 递归方法通过将问题分解为更小的子问题来工作。在这里，我们首先检查基本情况，即链表为空或只有...
JAVA简单实现单链表
qq_62274623的博客
05-16 215
以下是一个单链表的简单实现 将以图形和代码的形式进行描述以上就是今天要讲的内容，本文仅仅简单介绍了单链表的一些方法的实现.
Java数据结构-------单链表（图解增删改查详细实现，附反转链表实现）
执梗的博客
10-20 1335
目录 1.什么是链表？ 2.单链表的基本功能和结构 3.单链表基本功能代码具体实现 1.清空链表，获取链表长度，判断链表是否为空 2.获取指定位置的元素 3.像链表中添加元素t 4.向指定位置i处插入元素t 5.删除指定位置i处的元素，并返回该元素 6.查找元素第一次出现的位置 7.反转链表 1.什么是链表？ 一：链表是什么 1、链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的...
Java数据结构-单链表
最新发布
QUIXOTIC_的博客
03-29 1120
单链表
数据结构之单链表（java版）
qq_42489613的博客
10-23 1354
数据结构就是用某种结构去储存数据
数据结构——单链表（Java实现）
m0_52861211的博客
03-26 1843
单链表增删改查，排序，反转，倒序打印，两条单链表合并
Java 单链表知识点总结及代码实现
路先生的杂货铺，学习总结+好文分享
09-27 742
JAVA实现单链表 本文通过JAVA实现单链表的基本功能 实现功能 单链表的： 头部增加、头部删除 尾部增加、尾部删除 增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示； 全新的 KaTeX数学公式 语法； 增加了支持甘特图的mermaid语法1 功能； 增加了 多屏幕编辑 Markdown文章功能； 增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能...
java——单链表的实现
m0_60178502的博客
05-14 3413
目录 单链表的组成： 1.Node类（节点类） 2.SingleLinkedList类 单链表的实现： add del modify check show 单链表的测试： 单链表的组成： java中单链表的实现由两个类组成，分别是： 1.Node类（节点类） public class Node { //data域 public int age; public String name; //next域 public N
java实现单链表
热门推荐
congge
03-06 4万+
链表是java数据结构中一种很基础很常见却也很重要的数据结构，JDK中许多内置jar包基于单链表实现，比如像我们熟悉的linkedList等，为什么要使用链表呢？ 我们知道java中很多集合的底层是基于数组实现的，数组有一个很重要的结构就是索引，通过索引可以快速定位数据，并对数据进行删除等操作，但问题是，我们的业务中，数组有自身的局限性，如果知道索引还好，如果不知道索引就需要一个个遍历查找，然后再...
Java-单向链表和双向链表的实现和概念
夏寻的博客
06-30 436
单向链表只有后一节点指针，在节点删除，移动的时候，需要暂存前一节点，删除的时候将前一节点和后一节点连接，因为比双向链表少维护一个前节点，只在删除的时候暂存，所以比双向链表节省资源，但是增加了操作的复杂性。双向链表有前后两个节点指针，可以回溯指针，方便节点删除，移动，在做删除操作时只需要将索引节点前后两个节点连接即可，但是相比单向链表会耗费额外资源。 二、链表优点 长度可变，扩展性好 内存利用高（可以不连续） 时间性能：查找O(n)、插入和删除O(1) 空间性能：不需要分配存储空间，只要有就
JAVA链表实现类（数据结构学习）
12-14
JAVA链表实现类（数据结构学习）.chm
java实现单链表增删改查的实例代码详解
12-11
package 数据结构算法.链表; /* *定义节点 * 链表由节点构成 */ public class Node<E> { private E e; //数据data private Node<E> next; //指向下一个节点 public Node() { } public Node(E e) { ...
java实现单链表中是否有环的方法详解
09-05
在Java编程中，单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用。这篇文章主要探讨的是如何判断一个单链表中是否存在环，这是一个重要的算法问题，特别是在...
java23种设计模式详解+源码(绝对详解)
08-10
本资源是本人学习需要，通过网上查询，摘取网上有关设计模式好的解释，再由个人整理而得，绝对详解，看代码时最好结合word文档的图解一起，学习使用。
Java实现单链表
金木编程
07-20 115
以上就是一个简单的单链表实现。请注意，这只是一个基本示例，实际上，链表可以实现更多的操作和功能，例如在特定位置插入节点、反转链表、查找节点等等。在Java中，你可以使用类来实现单链表。
Java数据结构之单链表（配图详解，简单易懂）
如风暖阳的博客
01-17 3951
Java数据结构之单链表（配图详解，简单易懂）
Java单向链表的实现
m0_73050958的博客
07-13 297
引言： 在计算机科学中，链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的引用。一、单向链表的定义单向链表是 一种线性数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的引用。链表的第一个节点称为头节点，最后一个节点称为尾节点，尾节点的指针指向null。二、单向链表的实现在Java 中，可以使用类来实现单向链表。每个节点可以定义为一个类，包含两个属性：数据和指向下一个节点的引用。一个简单的Java单向链表的实现示例：```java。
Java数据结构---链表的基本用法（如创建等基本使用方法）
gaoqiandr的博客
01-05 780
本文简单地介绍了如何使用Java实现数据结构中的链表
java实现opc ua详解
09-01
Java实现OPC UA的步骤如下： 第一步，首先需要引入OPC UA的Java开发库。目前市场上有很多供应商提供的OPC UA开发库，选择适合自己的库进行引用。这些库通常包含了OPC UA的客户端和服务器代码。 第二步，编写OPC UA客户端代码。OPC UA客户端主要用于与OPC UA服务器进行通信。通过在Java程序中引入OPC UA库提供的相关类和接口，可以创建一个OPC UA客户端实例。然后，通过该实例可以实现与服务器的连接、节点浏览、读写数据等功能。 第三步，编写OPC UA服务器代码。OPC UA服务器主要用于提供OPC UA服务，允许客户端与其进行通信。类似地，通过引入OPC UA库提供的相关类和接口，可以创建一个OPC UA服务器实例。然后，可以定义自己的节点和数据模型，并实现相应的方法用于处理客户端请求。 第四步，配置OPC UA服务器。将OPC UA服务器配置为可以被客户端访问，可以通过修改配置文件或者在代码中设置服务器的IP地址和端口号来实现。 第五步，测试和调试。在完成客户端和服务器的编写后，可以通过启动客户端和服务器来对其进行测试和调试。通过客户端可以访问服务器的节点并读写数据，通过服务器可以查看客户端请求并进行相应的响应。 总结起来，Java实现OPC UA的过程涉及到引入OPC UA库、编写客户端和服务器代码、配置服务器以及测试和调试。通过这些步骤，可以实现Java程序与OPC UA服务器的交互，实现数据的读写和通信。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

PRINT！

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值