Java单链表按顺序插入，CRUD

已于 2023-02-12 16:33:17 修改
阅读量337 收藏
点赞数
文章标签： java 开发语言 链表 数据结构
于 2022-12-27 19:27:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63541561/article/details/128460192
版权

目录

创建节点：

以人物排名添加节点：

显示链表：

修改链表：

删除节点：

求链表中有效节点的个数：

查找链表中倒数第n个节点：

翻转链表，破坏了链表结构：

以栈的方式从尾到头打印链表，不破坏链表结构：

最后运行代码：

创建节点：

class HeroNode{
    public int no;
    public String name;
    public String nickName;
    public 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 + '\'' +
                '}';
    }
}

以人物排名添加节点：

public void add(HeroNode heroNode) {
        //因为头结点不能动，则添加一个temp的节点作为指针，所添加的值为temp的后一个节点
        HeroNode temp = head;
        boolean flag = false;//标记添加的编号不存在，可以添加，默认为false
        while (true){
            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.printf("准备添加的英雄编号%d已经存在，不能添加\n",heroNode.no);
        }else{
            //添加的两种情况，1.添加到链表的末尾，2.插入temp之后
            heroNode.next = temp.next;
            temp.next = heroNode;
        }

    }

显示链表：

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;
        }

    }

修改链表：

//根据排名，进行链表修改
    public void updata(HeroNode newHeroNode){
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //根据no号修改改节点
        HeroNode temp = head.next;
        boolean flag = false;//表示是否找到节点，默认为没找到
        while(true){
            if(temp==null){
                break;//遍历完整个链表
            }
            if(temp.no==newHeroNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;

        }else {
            System.out.printf("没有找到与编号%d相同的节点",newHeroNode.no);
        }
    }

删除节点：

 public void del(int no){
        HeroNode temp = head;
        boolean flag = false;//标志是否找到待删除的节点
        while (true){
            if (temp.next==null){
                System.out.println("没有节点必须退出");
                break;
            }
            if (temp.next.no==no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if (flag){
            temp.next=temp.next.next;
        }else {
            System.out.printf("编号为%d的节点不存在",no);
        }
    }

求链表中有效节点的个数：

   public static int getLength(HeroNode head){
        if (head.next==null){
            return 0;
        }
        int length = 0;
        //定义一个辅助变量
        HeroNode cur = head.next;
        while (cur!=null){
            length++;
            cur = cur.next;
        }
        return length;
    }

查找链表中倒数第n个节点：

    public static HeroNode findLastIndeexNode(HeroNode head,int index){
        if(head.next==null){
            return null;
        }
        int size = getLength(head);
        if (size<=0||index>size){
            return null;
        }
        HeroNode cur = head.next;
        for (int i = 0; i < size-index; i++) {
            cur = cur.next;
        }
        return cur;
    }

翻转链表，破坏了链表结构：

    public static void reverSetList(HeroNode head){
        if (head.next==null||head.next.next==null){
            return;
        }
        HeroNode reversetHead = new HeroNode(0,"","");
        HeroNode cur = head.next;
        HeroNode next = null;
        while (cur!=null){
            next = cur.next;
            cur.next = reversetHead.next;
            reversetHead.next = cur;
            cur=next;
        }
        head.next = reversetHead.next;
    }

以栈的方式从尾到头打印链表，不破坏链表结构：

  public static void reversePrint(HeroNode head){
        if (head.next==null){
            return;
        }
        //创建一个栈，将各个节点压入栈
        Stack<HeroNode> stack = new Stack<HeroNode>();
        HeroNode cur = head.next;
        //将链表的所有节点压入栈
        while (cur!=null){
            stack.push(cur);
            cur = cur.next;
        }
        //将栈中的所有节点进行打印。pop出栈；
        while (stack.size()>0){
            System.out.println(stack.pop());
        }
    }

最后运行代码：

import java.util.Stack;

//在添加时，自动排序链表
//按顺序插入节点，再添加 根据排名，进行修改的方法
//单链表的删除,根据排名删除列表
public class PaiMingDianLianBiao {
    public static void main(String[] args) {
        HeroNode h1 = new HeroNode(1,"宋江","及时雨");
        HeroNode h2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode h3 = new HeroNode(3,"吴用","智多星");
        HeroNode h4 = new HeroNode(4,"林冲","豹子头");
        SingleLinkedList2 singleLinkedList = new SingleLinkedList2();
        singleLinkedList.add(h1);
        singleLinkedList.add(h3);
        singleLinkedList.add(h2);
        singleLinkedList.add(h4);
        singleLinkedList.list();
        System.out.println("============修改后的链表=============");
        HeroNode h5 = new HeroNode(2,"小卢","麒麟");
        singleLinkedList.updata(h5);
        singleLinkedList.list();
        singleLinkedList.del(1);
        System.out.println("=============删除后的链表==========");
        singleLinkedList.list();
        System.out.print("链表有效长度");
        System.out.println(getLength(singleLinkedList.head));
        System.out.println("查找链表倒数第一个节点");
        System.out.println(findLastIndeexNode(singleLinkedList.head, 1));
        System.out.println("============翻转链表，破坏了链表结构========");
        reverSetList(singleLinkedList.head);
        singleLinkedList.list();
        System.out.println("==========栈翻转打印链表========");
        reversePrint(singleLinkedList.head);
    }
    //求链表中有效节点的个数
    public static int getLength(HeroNode head){
        if (head.next==null){
            return 0;
        }
        int length = 0;
        //定义一个辅助变量
        HeroNode cur = head.next;
        while (cur!=null){
            length++;
            cur = cur.next;
        }
        return length;
    }

//查找链表中倒数第n个节点
    public static HeroNode findLastIndeexNode(HeroNode head,int index){
        if(head.next==null){
            return null;
        }
        int size = getLength(head);
        if (size<=0||index>size){
            return null;
        }
        HeroNode cur = head.next;
        for (int i = 0; i < size-index; i++) {
            cur = cur.next;
        }
        return cur;
    }
    //翻转链表，破坏了链表结构
    public static void reverSetList(HeroNode head){
        if (head.next==null||head.next.next==null){
            return;
        }
        HeroNode reversetHead = new HeroNode(0,"","");
        HeroNode cur = head.next;
        HeroNode next = null;
        while (cur!=null){
            next = cur.next;
            cur.next = reversetHead.next;
            reversetHead.next = cur;
            cur=next;
        }
        head.next = reversetHead.next;
    }
    //以栈的方式从尾到头打印链表，不破坏链表结构
    public static void reversePrint(HeroNode head){
        if (head.next==null){
            return;
        }
        //创建一个栈，将各个节点压入栈
        Stack<HeroNode> stack = new Stack<HeroNode>();
        HeroNode cur = head.next;
        //将链表的所有节点压入栈
        while (cur!=null){
            stack.push(cur);
            cur = cur.next;
        }
        //将栈中的所有节点进行打印。pop出栈；
        while (stack.size()>0){
            System.out.println(stack.pop());
        }
    }
}
class SingleLinkedList2 {
    HeroNode head = new HeroNode(0, "", "");
    public void add(HeroNode heroNode) {
        //因为头结点不能动，则添加一个temp的节点作为指针，所添加的值为temp的后一个节点
        HeroNode temp = head;
        boolean flag = false;//标记添加的编号不存在，可以添加，默认为false
        while (true){
            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.printf("准备添加的英雄编号%d已经存在，不能添加\n",heroNode.no);
        }else{
            //添加的两种情况，1.添加到链表的末尾，2.插入temp之后
            heroNode.next = temp.next;
            temp.next = heroNode;
        }

    }
    //显示链表
    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;
        }

    }

    //根据排名，进行链表修改
    public void updata(HeroNode newHeroNode){
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //根据no号修改改节点
        HeroNode temp = head.next;
        boolean flag = false;//表示是否找到节点，默认为没找到
        while(true){
            if(temp==null){
                break;//遍历完整个链表
            }
            if(temp.no==newHeroNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;

        }else {
            System.out.printf("没有找到与编号%d相同的节点",newHeroNode.no);
        }
    }
    public void del(int no){
        HeroNode temp = head;
        boolean flag = false;//标志是否找到待删除的节点
        while (true){
            if (temp.next==null){
                System.out.println("没有节点必须退出");
                break;
            }
            if (temp.next.no==no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if (flag){
            temp.next=temp.next.next;
        }else {
            System.out.printf("编号为%d的节点不存在",no);
        }
    }

}
class HeroNode{
    public int no;
    public String name;
    public String nickName;
    public 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 + '\'' +
                '}';
    }
}

运行结果:

HeroNode{no=1, name='宋江', nickName='及时雨'}
HeroNode{no=2, name='卢俊义', nickName='玉麒麟'}
HeroNode{no=3, name='吴用', nickName='智多星'}
HeroNode{no=4, name='林冲', nickName='豹子头'}
============修改后的链表=============
HeroNode{no=1, name='宋江', nickName='及时雨'}
HeroNode{no=2, name='小卢', nickName='麒麟'}
HeroNode{no=3, name='吴用', nickName='智多星'}
HeroNode{no=4, name='林冲', nickName='豹子头'}
=============删除后的链表==========
HeroNode{no=2, name='小卢', nickName='麒麟'}
HeroNode{no=3, name='吴用', nickName='智多星'}
HeroNode{no=4, name='林冲', nickName='豹子头'}
链表有效长度3
查找链表倒数第一个节点
HeroNode{no=4, name='林冲', nickName='豹子头'}
============翻转链表，破坏了链表结构========
HeroNode{no=4, name='林冲', nickName='豹子头'}
HeroNode{no=3, name='吴用', nickName='智多星'}
HeroNode{no=2, name='小卢', nickName='麒麟'}
==========栈翻转打印链表========
HeroNode{no=2, name='小卢', nickName='麒麟'}
HeroNode{no=3, name='吴用', nickName='智多星'}
HeroNode{no=4, name='林冲', nickName='豹子头'}

小俱的一步步
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
java数据结构与算法第四课——链表
baijaiyu的博客
05-18 927
一：引入 上一课中我们介绍了顺序表，由于其底层是一段连续空间，当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。 为了解决这一问题，java集合中又引入了LinkedList，即链表结构。 二：链表 2.1链表的概念 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。 链表.........
java 链表插入排序,详解直接插入排序算法与相关的Java版代码实现
weixin_39815435的博客
03-21 239
直接插入排序直接插入排序的思路很容易理解，它是这样的：1.把待排序的数组分成已排序和未排序两部分，初始的时候把第一个元素认为是已排好序的。2.从第二个元素开始，在已排好序的子数组中寻找到该元素合适的位置并插入该位置。3.重复上述过程直到最后一个元素被插入有序子数组中。4.排序完成。示例：思路很简单，但代码并非像冒泡排序那么好写。首先，如何判断合适的位置？大于等于左边、小于等于右边？不行，很多边界条...
java 链表插入排序_链表插入排序_leetcode147
weixin_30247915的博客
03-07 326
题目描述对链表进行插入排序。从第一个元素开始，该链表可以被认为已经部分排序(用黑色表示)。每次迭代时，从输入数据中移除一个元素(用红色表示)，并原地将其插入到已排好序的链表中。插入排序算法：插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。重复直到所有输入数据插入完为止。解题思...
java数据结构之单链表类的设计与顺序插入和就地排序算法
m0_37942202的博客
08-21 1240
首先创建节点类Node. 单链表是由节点构成，节点类包含两个成员属性，一个是数据元素，一个是下一个节点的对象引用。 class Node { private Object element;//数据元素 private Node next;//下一个节点的对象引用 Node(Node next)//头节点构造函数 { thi......
Java 对链表进行插入排序
weixin_53545457的博客
01-15 391
对链表进行插入排序中等给定单个链表的头head，使用插入排序对链表进行排序，并返回排序后链表的头。插入排序算法的步骤:插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。重复直到所有输入数据插入完为止。下面是插入排序算法的一个图形示例。部分排序的列表(黑色)最初只包含列表中的第一个元素。每次迭代时，从输入数据中删除一个元素(红色)，并就地插入已排序的列表中。
java CRUD小工具，免安装
最新发布
01-06
快速生成增删改查sql、表对应的实体类、DB层的接口类，直接复制到项目中直接使用
Java连接mysql实现crud
09-14
用Java编写链接mysql数据库，内附sql文件，有注释，适合新手学习
es-crud:使用Java API的ElasticSearch CRUD操作
05-02
ElasticSearch CRUD 在这个项目中，我已经使用Java API完成了ElasticSearch CRUD（创建读取更新和删除）操作。 这个项目对初学者学习非常有帮助。先决条件安装 ，然后启动elasticSearch。跑步将该项目作为Maven导入...
SQL.rar_java sql crud
09-21
java代码，通过jdbc驱动链接mysql数据库，并对数据库进行增删改查
Java对数据库CRUD DEMO
04-20
Java对数据库增删改查（CRUD）操作。省去每次只能在数据库单条插入或者修改记录。一个操作数据量的CRUD工具集合。
基于单链表实现直接插入排序算法详解
sunnyoldboy博客
09-26 7867
插入排序属于稳定排序法，是一种常用的排序算法。直接插入排序算法可以利用静态数组来实现，也可以使用静态链表或者单链表来实现。本文给出了直接插入算法的单链表实现方法。
链表插入排序java实现
WukongGo的博客
03-15 1007
插入排序的思想是：依次读取链表当前值，将其插入之前已排序好的部分中的正确位置，不断的向向已排序的新链表中添加新的节点，并且保证添加节点后的列表仍然有序，直至原链表遍历完毕。 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; *...
Leetcode-147. 对链表进行插入排序
qq_51570936的博客
07-19 170
力扣
JAVA:实现LinkListSort链表排序算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-13 380
JAVA:实现LinkListSort链表排序算法(附完整源码)
插入排序 链表 java_单链表实现直接插入排序（JAVA）
weixin_35823048的博客
02-12 520
去面试问了单链表实现快排的问题，所以想来把八大排序算法的单链表实现总结一下。 这篇就先总结直接插入排序。实际上，算法就是把原来的单向链表断开，变成前面的有序链表，和后面的待排序链表，各用两个指针控制，将待排序链表中的结点，一个个与有序链表中的结点作比较，找到应该插入的位置，执行操作。在插入时，要考虑其插入点的特殊性，比如链首和链尾操作的不同。public LNode StraightInserti...
数据结构与算法 - 插入排序Java代码实现
能力工场小马哥
11-13 916
插入排序的Java代码实现
Java实现数据结构----插入排序直接插入排序
m0_56642224的博客
03-14 1661
七大基于比较的排序之插入排序-直接排序 直接插入排序-原理 主要步骤： 1.先假设第一个元素已经排好序 2.然后依次取出还需要进行排序的下一个元素，也就是排序完成的元素后面的下一个元素，取出下一个元素，设为待插入元素，在已经排序的元素序列中从后向前扫描，如果该元素（已排序）大于待插入元素，将该元素移到下一位置。 3.重复步骤2，直到找到已排序的元素小于或者等于待排序元素的位置，插入元素 4. 重复2，3的步骤，完成排序。 这样说可能还是有很多人不理解，那就画图来说明一下吧： 实现 性能分析 折半插入排
Java【直接插入排序】算法, 大白话式详细图文解析(附代码)
yzhcjl_的博客
03-14 2465
学数据结构与算法怎么少得了排序? 七大排序算法之[直接插入排序]详细图解, 结尾附[总体对比分析]
数据结构与算法（java）：直接插入排序
lalala_dxf的博客
09-27 121
基本原理 通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。 原理图 效果图 代码实现 ...
java crud 案例
08-01
1. Create：创建操作可以通过在student_table中插入一条新的记录来实现，可以使用Java的JDBC（Java Database Connectivity）库来连接数据库，并执行插入操作。 2. Read：读取操作可以通过在student_table中查询记录...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小俱的一步步

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

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

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

打赏作者

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

抵扣说明：

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

余额充值