单链表——Java实现增删改查以及按一定顺序插入

最新推荐文章于 2022-09-07 22:08:20 发布
最新推荐文章于 2022-09-07 22:08:20 发布
阅读量499 收藏 1
点赞数 1
文章标签： java 数据结构 单链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoyummm/article/details/114786220
版权

单链表

视频学习地址：https://www.bilibili.com/video/BV1E4411H73v?p=16
​ 链表中的数据是以结点来表示的，其通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的，每个结点只有一个链域的链表称为单链表。

在内存中存储方式示意图:

在这里插入图片描述

特点：

  • 链表是以节点的方式来存储
  • 每个节点包含data域，next域（指向下一个节点）
  • 链表各个节点不一定是连续存储的
  • 链表分带头节点的链表和没有头节点的链表，需要根据实际需求确定

单链表结构示意图：
在这里插入图片描述

实例：

实体类：单链表中每个节点就是这个类的一个对象

class HeroNode{
    int no;
    String name;
    String nickName;
    HeroNode next;

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

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

SingleLinkedList管理链表的类，用来实现具体功能：

1.添加节点
1.1 思路：
  • 通过temp辅助变量，找到当前链表的最后节点
  • 将最后节点的next 指向新的节点
/**
 * 管理链表的类
 */
class SingleLinkedList{
    //定义头节点
    private HeroNode head = new HeroNode(0,"","");

    public HeroNode getHead(){
        return this.head;
    }

    /**
     * 添加节点
     * @param heroNode
     */
    public void add(HeroNode heroNode){
        HeroNode temp = head;
        //while循环找到最后的节点
        while(true){
            if(temp.next == null){
                break;
            }
            temp = temp.next;
        }
        temp.next = heroNode;
    }

}
1.2测试用例：
public class SingleLinkedListDemo {
    public static void main(String[] args) {

        HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");

        SingleLinkedList list = new SingleLinkedList();
        list.add(hero1);
        list.add(hero2);
        list.add(hero3);
        list.add(hero4);

        list.list();

    }
}
1.3测试结果：

在这里插入图片描述

2. 遍历链表
2.1 思路：
  • 判断链表是否为空
  • 通过temp辅助变量进行遍历
/**
 * 管理链表的类
 */
class SingleLinkedList{
    //定义头节点
    private HeroNode head = new HeroNode(0,"","");

    public HeroNode getHead(){
        return this.head;
    }

     /**
     * 显示链表（遍历）
     */
    public void list(){
        if(head.next == null){
            System.out.println("当前链表为空~");
            return;
        }
        HeroNode temp = head.next;
        //遍历列表
        while (true){
            if(temp == null){
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }

}
2.2测试用例：

同上

2.3测试结果：

同上

3. 根据no，修改节点信息
3.1 思路：
  • 遍历链表
  • 找到与heroNode的no值相同的节点
  • 修改对应信息
/**
 * 管理链表的类
 */
class SingleLinkedList{
    //定义头节点
    private HeroNode head = new HeroNode(0,"","");

    public HeroNode getHead(){
        return this.head;
    }

    /**
     *根据no，修改节点信息
     * @param heroNode
     */
    public void update(HeroNode heroNode){
        if(head.next == null){
            System.out.println("该链表为空~");
            return;
        }
        HeroNode temp = head.next;
        boolean flag = false;
        //遍历链表，找到与heroNode的no值相同的节点
        while (true){
            if(temp == null){
                break;
            }
            if(temp.no == heroNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            temp.name = heroNode.name;
            temp.nickName = heroNode.nickName;
        }else{
            System.out.println("未找到对应的节点~");
        }
    }

}
3.2测试用例：
public class SingleLinkedListDemo {
    public static void main(String[] args) {

        HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");
        HeroNode hero5 = new HeroNode(1,"小宋","及时雨");

        SingleLinkedList list = new SingleLinkedList();
        list.add(hero1);
        list.add(hero2);
        list.add(hero3);
        list.add(hero4);

        System.out.println("修改之前~~~");
        list.list();
        System.out.println("修改之后~~~");
        list.update(hero5);
        list.list();

    }
}
3.3测试结果：

在这里插入图片描述

4. 删除节点
4.1 思路：
  • 遍历链表
  • 找到要删除的节点的前一个节点
  • 此时temp指向待删节点的前一个节点
  • 将temp.next 指向 temp.next.next
/**
 * 管理链表的类
 */
class SingleLinkedList{
    //定义头节点
    private HeroNode head = new HeroNode(0,"","");

    public HeroNode getHead(){
        return this.head;
    }

     /**
     * 删除节点
     * @param no
     */
    public void del(int no){
        if(head.next == null){
            System.out.println("该链表为空~");
            return;
        }

        HeroNode temp = head;
        boolean flag = false;

        while (true){
            if(temp == null){//遍历到最后节点
                break;
            }
            if(temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }

        if(flag){
            temp.next = temp.next.next;
        }else {
            System.out.println("未找到要删除的节点~");
        }
    }

}
4.2测试用例：
public class SingleLinkedListDemo {
    public static void main(String[] args) {

        HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");

        SingleLinkedList list = new SingleLinkedList();
        list.add(hero1);
        list.add(hero2);
        list.add(hero3);
        list.add(hero4);

        System.out.println("删除之前~~~");
        list.list();
        System.out.println("删除之后~~~");
        list.del(1);
        list.list();

    }
}
4.3测试结果：

在这里插入图片描述

5. 根据no的大小，顺序插入
5.1思路:
  • 通过temp临时变量，找到新增节点的正确位置
  • 新的节点的next 指向 temp.next
  • temp.next 指向新的节点
/**
 * 通过no顺序排列
 * @param heroNode
 */
public void addByOrder(HeroNode heroNode){

    HeroNode temp = head;
    boolean flag = false;

    while (true){
        /**
         * 表示两种情况
         * 1、当链表无节点时，直接跳出循环
         * 2、当链表循环到最后时，跳出循环
         */
        if (temp.next == null){
            break;
        }
        if(temp.next.no > heroNode.no ){
            break;
        }else if(temp.next.no == heroNode.no ){
            flag = true;
            break;
        }
        temp = temp.next;
    }

    if (flag){
        System.out.println("该节点已经存在~");
    }else{
        heroNode.next = temp.next;
        temp.next = heroNode;
    }
}
5.2测试用例：
public class SingleLinkedListDemo {
    public static void main(String[] args) {

        HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");

        SingleLinkedList list = new SingleLinkedList();
        list.addByOrder(hero2);
        list.addByOrder(hero4);
        list.addByOrder(hero1);
        list.addByOrder(hero3);

        list.list();

    }
}
5.3测试结果：

在这里插入图片描述

XIaoyummm
关注
Java基础学习总结（73）——Java最新面试题汇总
科技D人生
11-09 1638
1.super()与this()的区别？ this（）：当前类的对象,super父类对象。 super（）：在子类访问父类的成员和行为,必须受类继承规则的约束 而this他代表当前对象,当然所有的资源都可以访问. 在构造函数中,如果第一行没有写super(),编译器会自动插入.但是如果父类没有不带参数的构造函数,或这个函数被私有化了(用private修饰).此时你必须加入对
JAVA数据结构之单链表
weixin_42145631的博客
08-20 351
链表是以节点的方式来存储,是链式存储每个节点包含 data 域， next 域：指向下一个节点.如图：发现链表的各个节点不一定是连续存储.链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定单链表(带头结点)逻辑结构示意图如下。
Java单链表增删改查的实现
08-15
Java实现单链表的增删改查以及选择、冒泡、反转排序等功能的实现！
单链表的增删改查--java实现
码农界扛把子的博客
03-19 310
单链表的增删改查 public class MyLinked { Node first; int size; //在单链表末尾插入 public void add(Object value){ Node node=new Node(value); if(first==null){ first=node; }else { Node stemp=first; while (stemp.next!=nu...
java单链表的增删改查
interesting_code的博客
01-28 448
说在前面：过年这几天想学习却静不下心，一个单链表看了5天，，，咳咳，好了，现在来总结下但单链表的一些简单的东西 1.什么是链表 链表是有序的列表，但是他在内存中的存储和列表并不一样，如图 链表是以节点的方式来存储数据的，是链式存储，他的每个节点分为两部分，data域和next指针域，data域是用来保存该节点的数据，next域用来指向下一个节点，所以链表中的各个节点并不一定是连续存储的。 逻辑示...
java 单链表的增删改查
a123456horizon的博客
07-06 166
通过java中逻辑，实现c语言中的指针功能，文中主要含有增和删的功能，改和查比较简单，有索引就可以直接找到相关节点，然后修改相关属性。 package com.mf.link; public class SingleLink { Node head = null; // 头节点 class Node{ Node next; int data; public Node(int data){ this.data = data; } } public void addNod
Java单链表的增删改查
社会你浩辰哥的博客
02-29 217
/* Cấu trúc dữ liệu và thuật toán */ package yanhaochen; public class hello{ public static void main(String[] args) { HeroNode hero1 = new HeroNode(1,"宋哥","及时雨"); HeroNode he...
数据结构——链表的简单实现增删改查以及合并（C语言）
明宇逸风的博客
01-31 1147
链表的简单实现什么是链表代码的实现链表的结构体相应功能的函数实现初始化链表链表数据的插入链表数据的删除按位置查找数据元素合并两个链表输出链表相应功能集成调用主函数运行截图 什么是链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在
数据结构与算法(java版)——单链表(single-linked list)
Kätzchen-408的博客
04-04 1128
单链表（single-linked list）链表结构应用实例分析数据结构算法类方法对象代码实现插入向尾部直接插入节点思路分析算法实现按照顺序插入指定位置思路分析算法实现修改思路分析代码实现删除思路分析代码实现查找思路分析代码实现面试题有效元素的个数代码实现查找倒数第k个值[新浪面试题]思路分析算法实现单链表的反转[腾讯面试题]思路分析算法实现从尾到头打印单链表[百度面试题]思路分析算法实现 链表结构 node包含data+next,指向下一个结点的地址。链式存储。 链表分为带头结点的链表和没有头结点的链
JAVA基础（六）——Java常用包、数组、集合框架容器Collection（list、set）、map的用法、迭代器Iterator
qq_42540547的博客
12-04 273
1.Java常用包： java.lang 详解： http://beyond429.iteye.com/blog/344024 java.util 详解： http://blog.csdn.net/abeetle/article/details/1497706 java.io 详解： http://blog.csdn.net/yczz/article/details/38...
单链表的增删改查(Java)
qq_39792300的博客
09-07 185
单链表的增删改查(Java)
java创建单链表_java创建单链表及增删改查功能实现
weixin_39596835的博客
02-20 137
单链表节点类描述如下public class Node {public Object data; //存放节点值public Node next; //后继节点的引用 ,将data，next定义为public类型，就不需要get，set方法了public Node(){this(null,null); //无参时构造函数}public Node(Object data){ ...
Java 单链表（增删改查操作）
weixin_47143897的博客
12-01 2420
一、单链表介绍 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以节点来表示的，每个节点的构成：data域（数据元素）+next域（下一个结点的存储位置）。 单链表与数组相比的最大差别是：单链表的数据元素存放在内存空间的地址是不连续的，而数组的数据元素存放的地址在内存空间中是连续的，这也是为什么根据索引无法像数组那样直接就能查询到数据元素。 对于单链表的这种特殊结构，我们可以用“火车”来类比，假设一节车厢可以存储一个数据元素，当数据不够时，就新增一节车.
Java实现单链表的增删改查
shaochong的专栏
01-19 495
package interview; public class LinkedList { private static Node node; static class Node { int value; Node next; } static { create(); } public static Node create() { node = new Node(); ret.
JAVA实现单链表的增删改查
weixin_44341126的博客
09-26 192
JAVA实现单链表的增删改查 思路实现 定义 head=null,tali=null head是头节点，tail是尾节点。 代码实现 public class Chain { /** * * @author 远航小陈家 * Node:定义node的结构 * */ class Node { public int data; public Node next; } /** * 定义头节点和尾节点 * 尾节点永远指向最后一个元素 */
java单链表 提供增删改查_【Java】单链表的增删改查
weixin_28862561的博客
02-24 70
public class MyLinkedList {static class ListNode {int val;ListNode next;public ListNode(int val){this.val = val;}}ListNode head;// 头结点ListNode tail;// 尾结点int size;public MyLinkedList(){head = null;tai...
Java数据结构（3）----单链表的增删改查
qq_44752800的博客
04-25 196
单链表 写在开头的话： 业精于勤而荒于戏 大一的时候学的c++数据结构，没怎么用心学，但是目前自己走java方向，就要重新学会用java学数据结构，敲数据结构，希望大家一起努力吧 大一没多用心学专业，但是现在大二了，应该努力了，不能给自己留下遗憾，毕竟我们也是靠这个吃饭的，我们一起加油，有问题欢迎留言。 正文 链表由一系列节点组成，这些节点不必在内存中相连。每个节点均含有表元素和到包含该元素后继元...
java单链表 提供增删改查_单链表的增删改查--java实现
weixin_39793794的博客
02-24 50
单链表的增删改查public class MyLinked {Node first;int size;//在单链表末尾插入public void add(Object value){Node node=new Node(value);if(first==null){first=node;}else {Node stemp=first;while (stemp.next!=null){stemp=s...
单链表操作详解：增删改查与有序无序处理
这些操作展示了单链表增删改查的基本用法，包括有序和无序情况下的处理方式。 总结来说，单链表作为一种基础数据结构，提供了灵活的插入和删除操作，但在查找和删除节点时可能效率较低。在实际应用中，需要根据具体...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值