Java如何实现单链表的增删改查

一、新建学生节点类

Stu_Node节点包含:

学号:int num;

姓名:String name;

性别:String gender;

下一个节点:Stu_Node next;

为了便于打印节点内容需要重写toString方法

class Stu_Node{
    int num;
    String name;
    String gender;
    Stu_Node next;

    @Override
    public String toString() {
        return "Stu_Node{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
    public Stu_Node(int num, String name, String gender){
        this.num=num;
        this.name=name;
        this.gender=gender;
    }
}

二、新建一个操作链表的类,实现增删改查方法

1>创建链表的实现类对象

class SingleLinkedList{

}

2>在类里实现尾结点添加链表节点方法

1、定义一个头结点head为空。

2、定义一个节点变量temp等于头结点head。

3、遍历链表找到尾结点。

while循环,结束的标志是temp的下一个节点为空,此时终止while(否则程序会陷入死循环),循环每进行一次要把temp节点的下一个节点赋值给temp变量(否则程序会陷入死循环)。

4、使temp节点的下一个节点指向新增的节点。

class SingleLinkedList{
    Stu_Node head = new Stu_Node(0,"null","null");
    //链表的尾节点添加方法
    public void add(Stu_Node node){
        Stu_Node temp = head;
        while(true){
            if (temp.next==null){
                break;
            }
            temp = temp.next;
        }
        temp.next=node;
    }

}

按学号顺序插入节点

1、新建临时节点temp

2、新建boolean变量flag用于找到当前带插入节点的位置

3、while循环遍历链表找到插入节点位置,如果temp的下一节点为空表示链表已经遍历完毕此时终止循环;如果temp的下一节点的学号等于要插入的节点学号,此时将flag变量赋值为true结束循环(带插入的节点已经存在插入失败);如果temp节点的下一节点的学号大于带插入节点的学号,此时temp下一节点指向的位置就是要插入的位置。每次链表遍历一次节点要将temp的下一节点赋值给temp节点避免死循环。

4、如果flag为真表示,要插入的节点已经存在,输出插入失败;如果flag为假,令插入节点的下一节点指向temp的下一节点,temp节点的下一节点指向带插入节点。(画图方便理解,图自行脑补)

public void addOrder(Stu_Node node){
        Stu_Node temp = head;
        boolean flag = false;
        while(true){
            if (temp.next==null)
                break;
            if (temp.next.num >node.num){
                break;
            }
            else if (temp.next.num==node.num){
                flag = true;
                break;
            }
            temp=temp.next;
        }
        if (flag){
            System.out.println("插入失败");
        }
        else{
            node.next=temp.next;
            temp.next=node;
        }

    }

3>打印链表

1、判断头结点的下一个节点是否为空,如果为空输出链表为空。

2、定义一个temp节点变量,将头结点的指向的节点赋值给temp。

3、遍历链表打印节点数据。

while循环,打印链表节点,每打印一次temp节点,使temp节点的下一节点赋值给temp避免程序陷入死循环,循环结束标志是temp的节点为空(因为temp节点是头结点head的下一节点)。

class SingleLinkedList{
    Stu_Node head = new Stu_Node(0,"null","null");
    //打印单链表
    public void print(){
        if (head.next==null){
            System.out.println("链表为空");
        }
        Stu_Node temp = head.next;
        while(true){
            if (temp==null){
                break;
            }
            System.out.println(temp);
            temp=temp.next;
        }
    }
}

4>修改链表中的数据(假设学号为维一值)

1、首先判断链表是否为空

2、定义一个临时变量temp将头结点赋值给temp

3、定义一个Boolean变量flag用于判断链表中是否存在要修改的节点。

4、遍历链表,while循环查询要修改的节点,每查询一次就将temp变量赋值为temp的next节点,如果查询到要修改的节点将flag变量赋值为真、终止while循环,如果temp的下一节点为空表示未找到要修改的节点变量,此时也终止循环。

5、判断flag值为真代表找到当前要修改的节点,将要新的节点的值赋值给要修改节点的值;如果flag为假表示未找到当前节点。

class SingleLinkedList{
    Stu_Node head = new Stu_Node(0,"null","null");
    //链表的修改方法
    public void update(Stu_Node newnode){
        if (head.next==null){
            System.out.println("链表为空");
        }
        Stu_Node temp = head;
        boolean flag = false;
        while (true){
            if (temp.next==null){
                break;
            }
            if (temp.num== newnode.num){
                flag = true;
                break;
            }
            temp=temp.next;
        }
        if (flag){
            temp.name=newnode.name;
            temp.gender= newnode.gender;
        }
        else
            System.out.println("当前节点不存在,无法修改!");
    }
}

5>依据学号删除节点

1、定义一个临时节点temp,将头结点赋值给temp

2、定义一个boolean型变量flag用于判断是否找到当前链表中待删除的节点

3、while循环遍历当前链表,每遍历一次节点,将temp节点的下一节点赋值给temp避免循环,如果待删除节点的学号跟要删除的节点的学号一至,将flag赋值为true终止while循环,否则持续遍历链表直到temp节点的下一节点为空终止循环。

4、如果flag为真,代表找到当前要删除的节点,将temp的下一节点指向temp下一节点的下一节点。,如果flag为假代表找不到待删除的节点。

class SingleLinkedList{
    Stu_Node head = new Stu_Node(0,"null","null");
    //删除链表的节点
    public void delete(int no){
        Stu_Node temp = head;
        boolean flag = false;
        while(true){
            if (temp.next==null)
                break;
            if (temp.next.num==no){
                flag=true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.next=temp.next.next;
        }
        else{
            System.out.println("未找到要删除的链表");
        }

    }
}

三、新建操作链表类的实现类实现其增删改查功能

1、新建操作链表类的实现类对象

2、新建多个待操作的节点

3、使用新建的链表操作类对象进行增删改查功能

完整代码如下:

public class linkedlist {
    public static void main(String[] args) {
        SingleLinkedList list = new SingleLinkedList();
        Stu_Node node1 = new Stu_Node(1903210086,"小明","男");
        Stu_Node node2 = new Stu_Node(1903210087,"小花","女");
        Stu_Node node3 = new Stu_Node(1903210088,"小黄","男");
        Stu_Node node4 = new Stu_Node(1903210089,"小翠","女");
        list.add(node1);
        list.add(node4);
        list.add(node3);
        list.add(node2);
        list.print();
        System.out.println("----------------------");
        System.out.println("按学号顺序插入节点");
        SingleLinkedList list_1= new SingleLinkedList();
        list_1.addOrder(node1);
        list_1.addOrder(node4);
        list_1.addOrder(node3);
        list_1.addOrder(node2);
        list_1.print();
        System.out.println("-----------------------");
        Stu_Node node5 = new Stu_Node(1903210089,"贾明","男");
        list.update(node5);
        list.print();
        System.out.println("#######################");
        System.out.println("删除之后的链表");
        list.delete(1903210088);
        list.print();
    }
}
class Stu_Node{
    int num;
    String name;
    String gender;
    Stu_Node next;

    @Override
    public String toString() {
        return "Stu_Node{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
    public Stu_Node(int num, String name, String gender){
        this.num=num;
        this.name=name;
        this.gender=gender;
    }
}

class SingleLinkedList{
    Stu_Node head = new Stu_Node(0,"null","null");
    //链表的尾节点添加方法
    public void add(Stu_Node node){
        Stu_Node temp = head;
        while(true){
            if (temp.next==null){
                break;
            }
            temp = temp.next;
        }
        temp.next=node;
    }
    public void addOrder(Stu_Node node){
        Stu_Node temp = head;
        boolean flag = false;
        while(true){
            if (temp.next==null)
                break;
            if (temp.next.num >node.num){
                break;
            }
            else if (temp.next.num==node.num){
                flag = true;
                break;
            }
            temp=temp.next;
        }
        if (flag){
            System.out.println("插入失败");
        }
        else{
            node.next=temp.next;
            temp.next=node;
        }

    }
    public void print(){
        if (head.next==null){
            System.out.println("链表为空");
        }
        Stu_Node temp = head.next;
        while(true){
            if (temp==null){
                break;
            }
            System.out.println(temp);
            temp=temp.next;
        }
    }
    public void update(Stu_Node newnode){
        if (head.next==null){
            System.out.println("链表为空");
        }
        Stu_Node temp = head;
        boolean flag = false;
        while (true){
            if (temp.next==null){
                break;
            }
            if (temp.num== newnode.num){
                flag = true;
                break;
            }
            temp=temp.next;
        }
        if (flag){
            temp.name=newnode.name;
            temp.gender= newnode.gender;
        }
        else
            System.out.println("当前节点不存在,无法修改!");
    }
    public void delete(int no){
        Stu_Node temp = head;
        boolean flag = false;
        while(true){
            if (temp.next==null)
                break;
            if (temp.next.num==no){
                flag=true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.next=temp.next.next;
        }
        else{
            System.out.println("未找到要删除的链表");
        }

    }
}

总结

到此这篇关于Java如何实现单链表增删改查的文章就介绍到这了,更多相关Java单链增删改查内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • java实现单链表增删改查的实例代码详解

    package 数据结构算法.链表; /* *定义节点 * 链表由节点构成 */ public class Node<E> { private E e; //数据data private Node<E> next; //指向下一个节点 public Node() { } public Node(E e) { this.e = e; } public Node<E> getNext() { return next; } public void setNext(Node&l

  • Java 单链表数据结构的增删改查教程

    我就废话不多说了,大家还是直接看代码吧~ package 链表; /** * *1)单链表的插入.删除.查找操作: * 2)链表中存储的是int类型的数据: **/ public class SinglyLinkedList { private Node head = null; //查找操作 public Node findByValue(int value){ Node p = head; //从链表头部开始查找 while(p.next != null && p.data != va

  • Java如何实现单链表的增删改查

    一.新建学生节点类 Stu_Node节点包含: 学号:int num; 姓名:String name; 性别:String gender; 下一个节点:Stu_Node next; 为了便于打印节点内容需要重写toString方法 class Stu_Node{ int num; String name; String gender; Stu_Node next; @Override public String toString() { return "Stu_Node{" + &qu

  • Java实现单链表SingleLinkedList增删改查及反转 逆序等

    节点类 可以根据需要,对节点属性进行修改.注意重写toString()方法,以便后续的输出操作. //节点类 class Node { public int id; public String name; public Node next; public Node(int id, String name) { this.id = id; this.name = name; } @Override public String toString() { return "Node{" + &

  • Java单链表的增删改查与面试题详解

    目录 一.单链表的增删改查 1.创建结点 2.单链表的添加操作 3.单链表的删除操作 4.单链表的有效结点的个数 二.大厂面试题 一.单链表的增删改查 1.创建结点 单链表是由结点连接而成,所以我们首先要创建结点类,用于对结点进行操作.定义data属性 表示序号,定义name属性表示结点存放的数据信息,定义next属性表示指向下一个结点.构造器只需要放入data属性和name属性,重写toString方法方便打印结点信息. public class Node { public int data;

  • C语言数据结构之单链表与双链表的增删改查操作实现

    目录 前言 单链表的增删改查 定义结构体以及初始化 增加结点 删除结点 查找修改结点 移除结点 最终效果 双链表的基本操作 初始化建表 遍历双链表 指定位置插入结点 指定位置删除结点 查找结点位置 最终效果 结语 前言 上篇博客分享了创建链表传入二级指针的细节,那么今天就分享几个c语言课程实践设计吧.这些程序设计搞懂了的话相当于链表的基础知识牢牢掌握了,那么再应对复杂的链表类的题也就能慢慢钻研了.学习是一个积累的过程,想要游刃有余就得勤学苦练! 单链表的增删改查 (1)项目需求 构造带有头结点的

  • Mybatis基于xml配置实现单表的增删改查功能

    Mybatis入门-基于配置实现单表的增删改查 Mybatis简介 官网链接:https://mybatis.org/mybatis-3/zh/index.html.更加详细的信息可以去官网查看. MyBatis 是一款优秀的持久层框架,它支持自定义 SQL.存储过程以及高级映射.MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作.MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型.接口和 Java POJO(Plain Old Java Object

  • java jdbc连接mysql数据库实现增删改查操作

    jdbc相信大家都不陌生,只要是个搞java的,最初接触j2ee的时候都是要学习这么个东西的,谁叫程序得和数据库打交道呢!而jdbc就是和数据库打交道非常基础的一个知识,也是比较接近底层的,在实际的工作中大家用得更多的其实还是比较成熟的框架,例如Hibernate.Mybatis. 但是作为这些成熟框架的底层的jdbc却也是我们应该去掌握的,只有了解了jdbc的增删改查,这样在以后如果有兴趣去研究Hibernate或者Mybatis的源代码的时候才能更好的去理解这些成熟的框架是如何去实现增删改查

  • java对xml节点属性的增删改查实现方法

    学习本文之前请先看我的另一篇文章JAVA对XML节点的操作可以对XML操作有更好的了解. package vastsum; import java.io.File; import java.io.FileWriter; import java.util.Iterator; import org.dom4j.Attribute; import org.dom4j.Document; import org.dom4j.Element; import org.dom4j.io.SAXReader; i

  • Java实现RedisUtils操作五大集合(增删改查)

    前排提示,我在这个工具类加了@Component注解,如果在springboot的项目使用,记得通过@Autowired注入使用. import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.*; import org.springframework.stereotype.Component; import java.io.Serializabl

  • Java描述数据结构学习之链表的增删改查详解

    前言 链表是一种常见的基础数据结构,它是一种线性表,但在内存中它并不是顺序存储的,它是以链式进行存储的,每一个节点里存放的是下一个节点的"指针".在Java中的数据分为引用数据类型和基础数据类型,在Java中不存在指针的概念,但是对于链表而言的指针,指的就是引用数据类型的地址. 链表和数组都是线性的数据结构,对于数组而言其长度是固定的,由于在内存中其是连续的,因此更适合做查找与遍历,而链表在内存中是并不是顺序存储的,但是由于其是通过"指针"构成的,因此在插入.删除时

  • C语言中单链表的基本操作指南(增删改查)

    目录 1.链表概述 2.链表的基本使用 2.0 准备工作 2.1 创建节点(结构体) 2.2 全局定义链表头尾指针 方便调用 2.3 创建链表,实现在链表中增加一个数据(尾添加)----增 2.4 遍历链表 -----查 2.5 查询指定的节点 (遍历 一个个找) 2.6 链表清空------全部删除 2.7.在指定位置插入节点 ----在指定位置增 2.8尾删除----删 2.9 删除头------删 2.10 删除指定节点 3. 测试主程序 总结 1.链表概述 链表是一种常见的数据结构.它与

随机推荐