java实现单链表

已于 2024-07-10 16:13:44 修改
阅读量494 收藏 1
点赞数 2
分类专栏： 数据结构 文章标签： java 单链表 数据结构
于 2020-08-16 14:19:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28840013/article/details/108035096
版权

参考于 尚硅谷Java数据结构与java算法，韩顺平数据结构与算法

1.什么是链表：

链表是有序的列表，但是它在内存中可以以不连续空间存放，存储如下
单链表示意图
根据上图，可以发现：

  1. 链表是以节点的方式来存储，是链式存储
  2. 每个节点包含 data 域，next域:指向下一个节点.
  3. 链表的各个节点不一定是连续存储.
  4. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定（头节点一般不存储数据，只用于作为标识）
    因而带头节点的单链表的逻辑结构可以看作：
    在这里插入图片描述

2.单链表的实现

需求：
使用带head头节点的单链表；
每个节点data域有no（No.顺序）和name字段，和指向下一节点的next；
需要实现对每个节点的增删改查操作

实现思路与代码：

2.1 首先我们创建这个节点类：

//定义SingleNode，每个SingleNode对象就是一个节点
class SingleNode{
    public int no;
    public String name;  //no和name可以认为是节点的数据部分
    public SingleNode next;  //指向下一个节点

    //构造器
    public SingleNode(int no, String name)
    {
        this.no = no;
        this.name = name;
    }

    //为了显示方法，重新显示toString(不打印next节点，否则或造成将后续节点全部打印)
    @Override
    public String toString()
    {
        return "SingleNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
}

2.2 然后我们写一个链表类，初始化一个头节点，然后在链表类中编写链表的增删改查方法：

//定义一个SingleLinkedList 管理链表
class SingleLinkedList{
    //先初始化一个头节点,一般头节点不存储数据
    private SingleNode head=new SingleNode(0,"");
    }

2.3 添加节点的方法（这里按照需求，可以有两种添加方式）：

2.3.1 直接添加到链表的尾部

//添加节点到单向链表
    //当不考虑编号顺序时
    //1.找到当前节点的最后节点
    //2.将最后这个节点的next指向 新的节点
    public void add(SingleNode singleNode){
        //因为head头不能动，因此我们需要一个辅助遍历temp(类似于指针)，先将temp指向head节点
        SingleNode temp=head;
        //遍历链表，找到最后
        while (true){
            //找到链表的最后
            if(temp.next==null){
                break;
            }
            //如果没有找到最后，继续指向下一个
            temp=temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点的next，指向新的节点
        temp.next=singleNode;
    }

2.3.2 按照no将节点插入到指定位置（如果有这个no，则添加失败，并给出提示）
思路分析如下：
在这里插入图片描述

  1. 首先找到新添加的节点的位置是通过辅助变量temp(指针),通过遍历来搞定
  2. temp指向位于要添加位置的前一个节点
  3. 要添加的节点.next = temp.next
  4. 将temp.next=新添加的节点
//第二种方式在添加节点时，根据no将节点插入到指定位置
    //如果有这个no，则添加失败，并给出提示
    public void addByOrder(SingleNode singleNode){
        //因为头节点不能动，需要一个辅助指针来帮助找到添加的位置（指向前一位）
        //因为单链表，因此我们找的tmep是位于添加位置的前一个节点，否则插入不了
        SingleNode temp=head;
        boolean flag=false;//flag标志添加的编号是否存在，默认为false
        while(true){
            if(temp.next==null){//说明temp已经在链表的最后
                break;
            }
            if(temp.next.no>singleNode.no){ //位置找到，就在temp的后面插入
                break;
            }else if(temp.next.no==singleNode.no){ //说明希望添加的编号已经存在
                flag=true;//说明编号存在
                break;
            }
            temp=temp.next; //后移，遍历当前链表
        }
        //是否添加，判断flag的值
        if(flag){//不能添加，说明编号存在
            System.out.printf("准备插入的节点的编号 %d 已经存在了，不能加入\n",singleNode.no);
        }else {
            //插入到链表中，tmep的后面
            singleNode.next=temp.next;
            temp.next=singleNode;
        }
    }

2.3 修改节点data
思路分析如下：
（这里我们直接传入一个newNode，通过no找到节点，然后替换data）

  1. 先找到该节点,通过遍历
  2. temp.name = newNode.name ;
 //修改节点的信息，根据no编号来修改，即no编号不能改。
    //说明:根据newNode的no来修改即可
    public void update(SingleNode newNode){
        //判断是否为空
        if(head.next==null){
            System.out.println("链表为空~");
            return;
        }
        //找到需要修改的节点，根据no编号
        //先定义一个辅助遍历
        SingleNode temp=head.next;
        boolean flag=false;//表示是否找到该节点
        while(true){
            if(temp==null){
                break; //已经遍历完链表
            }
            if(temp.no==newNode.no){
                //找到
                flag=true;
                break;
            }
            temp=temp.next;
        }
        //根据flag 判断是否找到要修改的节点
        if(flag){
            temp.name=newNode.name;
        }else {
            System.out.printf("没有找到 编号 %d 的节点，不能修改\n",newNode.no);
        }
    }

2.4 删除节点：
思路分析如下：
在这里插入图片描述

  1. 我们先找到需要删除的这个节点的前一个节点temp
  2. temp.next = temp.next. next
  3. 被删除的节点，将不会有其它引用指向，会被垃圾回收机制回收
//删除节点
    //思路：
    //头节点不能动，需要一个辅助指针来帮助找到待删除节点的前一个节点
    //2.我们在比较时，时temp.next.no和需要删除的节点的no比较
    public void del(int no){
        SingleNode temp=head;
        boolean flag=false; //标志是否找到待删除节点
        while(true){
            if(temp.next==null){ //已经到链表末尾
                break;
            }
            if(temp.next.no==no){
                //找到的待删除节点的前一个节点temp
                flag=true;
                break;
            }
            temp=temp.next; //temp后移，遍历
        }
        if(flag){//找到。可以删除
            temp.next=temp.next.next; //删除的节点会因为垃圾回收机制被回收
        }else {
            System.out.printf("要删除的%d 节点不存在\n",no);
        }
    }

2.5 遍历链表

//显示链表，通过辅助变量 遍历
    public void list(){
        //判断链表是否为空
        if (head.next == null)
        {
            System.out.printf("链表为空");
            return;
        }
        //因为头节点，不能动，因此我们需要一个辅助变量来变量
        SingleNode temp=head.next;
        while (true){
            //判断是否到链表最后
            if(temp==null){
                break;
            }
            //不为空，输出节点信息
            System.out.println(temp);
            //将temp后移
            temp=temp.next;
        }
    }

2.6 组合代码，编写主函数进行测试

public class SingleLinkedListDemo
{
    public static void main(String[] args)
    {
        //进行测试
        //先创建节点
        SingleNode node1 = new SingleNode(1, "北京");
        SingleNode node2 = new SingleNode(2, "上海");
        SingleNode node3 = new SingleNode(3,"广州");
        SingleNode node4 = new SingleNode(4, "深圳");

        //创建一个单链表
        SingleLinkedList singleLinkedList=new SingleLinkedList();
        
        /*
        //加入
        singleLinkedList.add(node1);
        singleLinkedList.add(node2);
        singleLinkedList.add(node3);
        singleLinkedList.add(node4);
        */

        //加入按照编号的顺序
        singleLinkedList.addByOrder(node1);
        singleLinkedList.addByOrder(node2);
        singleLinkedList.addByOrder(node3);
        singleLinkedList.addByOrder(node4);
        singleLinkedList.list();

        //测试修改节点的代码
        SingleNode newHeroNode=new SingleNode(3,"重庆");        //显示
        singleLinkedList.update(newHeroNode);
        System.out.printf("修改后的链表：\n");
        singleLinkedList.list();

        //删除一个节点
        singleLinkedList.del(1);
        System.out.printf("删除后的链表情况：\n");
        singleLinkedList.list();
    }
}

运行结果：
运行结果

完整代码实现：

这里我们可以以内部类的方式编写该代码：
SingleLinkedListDemo.java:

/*
* 单链表
* */
public class SingleLinkedListDemo
{
    public static void main(String[] args)
    {
        //进行测试
        //先创建节点
        SingleNode node1 = new SingleNode(1, "北京");
        SingleNode node2 = new SingleNode(2, "上海");
        SingleNode node3 = new SingleNode(3,"广州");
        SingleNode node4 = new SingleNode(4, "深圳");

        //创建一个单链表
        SingleLinkedList singleLinkedList=new SingleLinkedList();

        /*
        //加入
        singleLinkedList.add(node1);
        singleLinkedList.add(node2);
        singleLinkedList.add(node3);
        singleLinkedList.add(node4);
        */

        //加入按照编号的顺序
        singleLinkedList.addByOrder(node1);
        singleLinkedList.addByOrder(node2);
        singleLinkedList.addByOrder(node3);
        singleLinkedList.addByOrder(node4);
        singleLinkedList.list();

        //测试修改节点的代码
        SingleNode newHeroNode=new SingleNode(3,"重庆");        //显示
        singleLinkedList.update(newHeroNode);
        System.out.printf("修改后的链表：\n");
        singleLinkedList.list();

        //删除一个节点
        singleLinkedList.del(1);
        System.out.printf("删除后的链表情况：\n");
        singleLinkedList.list();
    }
}

//定义一个SingleLinkedList 管理链表
class SingleLinkedList{
    //先初始化一个头节点，头节点不要动,一般头节点不存储数据
    private SingleNode head=new SingleNode(0,"");

    //添加节点到单向链表
    //当不考虑编号顺序时
    //1.找到当前节点的最后节点
    //2.将最后这个节点的next指向 新的节点
    public void add(SingleNode singleNode){
        //因为head头不能动，因此我们需要一个辅助遍历temp(类似于指针)，先将temp指向head节点
        SingleNode temp=head;
        //遍历链表，找到最后
        while (true){
            //找到链表的最后
            if(temp.next==null){
                break;
            }
            //如果没有找到最后，继续指向下一个
            temp=temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点的next，指向新的节点
        temp.next=singleNode;
    }

    //第二种方式在添加节点时，根据no将节点插入到指定位置
    //如果有这个no，则添加失败，并给出提示
    public void addByOrder(SingleNode singleNode){
        //因为头节点不能动，需要一个辅助指针来帮助找到添加的位置（指向前一位）
        //因为单链表，因此我们找的tmep是位于添加位置的前一个节点，否则插入不了
        SingleNode temp=head;
        boolean flag=false;//flag标志添加的编号是否存在，默认为false
        while(true){
            if(temp.next==null){//说明temp已经在链表的最后
                break;
            }
            if(temp.next.no>singleNode.no){ //位置找到，就在temp的后面插入
                break;
            }else if(temp.next.no==singleNode.no){ //说明希望添加的编号已经存在
                flag=true;//说明编号存在
                break;
            }
            temp=temp.next; //后移，遍历当前链表
        }
        //是否添加，判断flag的值
        if(flag){//不能添加，说明编号存在
            System.out.printf("准备插入的节点的编号 %d 已经存在了，不能加入\n",singleNode.no);
        }else {
            //插入到链表中，tmep的后面
            singleNode.next=temp.next;
            temp.next=singleNode;
        }
    }

    //修改节点的信息，根据no编号来修改，即no编号不能改。
    //说明:根据newNode的no来修改即可
    public void update(SingleNode newNode){
        //判断是否为空
        if(head.next==null){
            System.out.println("链表为空~");
            return;
        }
        //找到需要修改的节点，根据no编号
        //先定义一个辅助遍历
        SingleNode temp=head.next;
        boolean flag=false;//表示是否找到该节点
        while(true){
            if(temp==null){
                break; //已经遍历完链表
            }
            if(temp.no==newNode.no){
                //找到
                flag=true;
                break;
            }
            temp=temp.next;
        }
        //根据flag 判断是否找到要修改的节点
        if(flag){
            temp.name=newNode.name;
        }else {
            System.out.printf("没有找到 编号 %d 的节点，不能修改\n",newNode.no);
        }
    }

    //删除节点
    //思路：
    //头节点不能动，需要一个辅助指针来帮助找到待删除节点的前一个节点
    //2.我们在比较时，时temp.next.no和需要删除的节点的no比较
    public void del(int no){
        SingleNode temp=head;
        boolean flag=false; //标志是否找到待删除节点
        while(true){
            if(temp.next==null){ //已经到链表末尾
                break;
            }
            if(temp.next.no==no){
                //找到的待删除节点的前一个节点temp
                flag=true;
                break;
            }
            temp=temp.next; //temp后移，遍历
        }
        if(flag){//找到。可以删除
            temp.next=temp.next.next; //删除的节点会因为垃圾回收机制被回收
        }else {
            System.out.printf("要删除的%d 节点不存在\n",no);
        }
    }

    //显示链表，通过辅助变量 遍历
    public void list(){
        //判断链表是否为空
        if (head.next == null)
        {
            System.out.printf("链表为空");
            return;
        }
        //因为头节点，不能动，因此我们需要一个辅助变量来变量
        SingleNode temp=head.next;
        while (true){
            //判断是否到链表最后
            if(temp==null){
                break;
            }
            //不为空，输出节点信息
            System.out.println(temp);
            //将temp后移
            temp=temp.next;
        }
    }
}

//定义SingleNode，每个SingleNode对象就是一个节点
class SingleNode{
    public int no;
    public String name;  //no和name可以认为是节点的数据部分
    public SingleNode next;  //指向下一个节点

    //构造器
    public SingleNode(int no, String name)
    {
        this.no = no;
        this.name = name;
    }

    //为了显示方法，重新显示toString(不打印next节点，否则或造成将后续节点全部打印)
    @Override
    public String toString()
    {
        return "SingleNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
}
这是一个死肥宅
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 单链表实现
sauceliutong的博客
11-30 95
package com.tqnsyh.liutong; public class lb { private int size;//链表大小 private Node head;//头链表 public lb(){ size=0; head=null; } private class Node{ private Object data=null; private...
数据结构——链表(java)
薯条和番茄酱的博客
01-03 4204
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。
JAVA——链表
热门推荐
qq_69133469的博客
04-23 2万+
一、链表概念及结构 链表：链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。如下图：（通俗的说：就是由一个个节点组成，这些节点逻辑上连续，物理上不连续） 类比火车： singleLinkedList ——火车车次（一整个火车or哪趟火车） Node——车厢，具体储存元素的类，每个单链表的节点就是Node的一个对象 Node.head ；——当前链表的头节点（只要知道头节点就可以此访问链表中的所有节点） int size ；——当前链表的长度（节点个.
Java数据结构篇之链表
最新发布
MasterJundarj的博客
09-23 2876
/头插法//尾插法//任意位置插入,第一个数据节点为0号下标//查找是否包含关键字key是否在单链表当中//删除第一次出现关键字为key的节点//删除所有值为key的节点//得到单链表的长度int size();@Override@Override【解释】
【Java】链表LinkedList
qq_61635026的博客
07-06 9383
链表（Linked List）是一种常见的数据结构，用于存储和组织数据。它由一系列节点（Node）组成，每个节点包含两个主要部分：数据域（Data）和指针域（Pointer）。 数据域存储节点所需的数据或信息，可以是任意类型的数据，如整数、字符、对象等。指针域则指向链表中的下一个节点，将节点连接起来形成链表结构。 链表中的节点并不一定按照物理上的连续位置存储，而是通过指针域相互连接。这使得链表能够灵活地插入、删除和修改节点，而无需像数组那样进行元素的移动。
数据结构之单链表（java版）
qq_42489613的博客
10-23 1381
数据结构就是用某种结构去储存数据
Java实现单链表以及单链表的操作.zip
09-02
以上就是使用Java实现单链表及其实现的各种操作的详细解析。掌握这些基本操作，能帮助我们在处理复杂问题时更加得心应手。在实际编程中，根据具体需求，还可以扩展链表的功能，例如支持双向链表、循环链表等。
java实现单链表之逆序
09-03
本文将详细介绍如何使用Java实现单链表的逆序。 首先，我们需要定义一个单链表的节点类`Node`，它包含两个属性：`data`用于存储数据，`next`用于指向下一个节点。如以下代码所示： ```java class Node { int data...
Java链表入门(超详细)
qq_57735833的博客
07-25 1万+
说起链表,可以说是让刚接触数据结构的同学非常懵逼的那么什么是链表呢??链表（Linkedlist）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。那么这是链表吗,是的,但是究竟是什么意思呢其实,链表就像是解密游戏一样,只有到达一个地点,才会有NPC给你下一个地点的地图,从而才能知道下个地点的位置所以链表也是一样,对于一个链表,一个结点除了要保存结点自身的值以外,还需要保存下一个结点的地址....
Java单链表
weixin_73000974的博客
07-15 635
什么是链表链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点都包括两部分：一是数据域，用来存储元素数值数据，另一个是存储直接后继结点地址的指针域，该指针一般称为next，用来指向下一个结点的位置。由于下一个结点也是链表类型，所以next的指针也要定义为链表类型。链表概念及特点头指针：是指向链表中第一个结点的指针首元结点：是指链表中存储的第一个数据元素的结点。
数据结构——单链表（Java实现）
m0_52861211的博客
03-26 1875
单链表增删改查，排序，反转，倒序打印，两条单链表合并
Java中的链表
weixin_52758364的博客
12-09 3359
以实践为线索，逐步深入数据结构和算法，提升编程能力和思维能力。
数据结构之实现单链表(Java实现)
weixin_47851265的博客
12-22 3178
数据结构之单链表的实现
Java实现单链表（步骤详解+源码）
GSCY
10-14 6769
Java实现单链表（步骤详解+源码） 欢迎大家提出问题，一起学习！
JAVA基础-链表
lwxklts的博客
02-02 706
链表由一系列结点组成，每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。相比于线性表顺序结构，操作复杂。链表在插入的时候速度较快，可以达到O(1)的复杂度，但是查找操作较慢，需要O(n)的时间，线性表和顺序表查找操作的时间复杂度分别是O(logn)和O(1)。链表的物理存储结构是非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接的次序实现的.利用尾节点last尾插法插入结点。先查找结点比对结点值再删除。在指定结点前添加结点。
Java算法进阶(一):链表
Justin_Andyson的博客
04-11 930
Java算法链表的深究
Java数据结构--单链表
m0_74808313的博客
04-21 1300
我们在实现单向链表之前，先了解一下Java API中LinkedList类的方法摘要，并学会如何去创建使用链表，熟练运用其中常用的几种方法(增删差)下面为LinkedList类中的所有方法摘要看到这么多方法，是不是头都大了，但不要慌，我们只需熟练掌握其中最常用的几种方法即可，其余的只需了解。下面我们来运行一下其中最常用的几种方法(我们要实现的也是以下主要方法)addFirst(元素) 将指定元素添加到链表开头add(元素)将指定元素添加到链表结尾。
java实现单链表删除给定值
04-01
以下是Java实现单链表删除给定值的示例代码： ``` class ListNode { int val; ListNode next; ListNode(int x) { val = x; } } class Solution { public ListNode removeElements(ListNode head, int val) { ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值