单向链表的增删改查

最新推荐文章于 2024-09-29 15:26:10 发布
最新推荐文章于 2024-09-29 15:26:10 发布
阅读量330 收藏 1
点赞数 2
分类专栏： 数据结构 文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56184347/article/details/118692621
版权
本文详细介绍了单链表的逻辑结构，包括节点属性、添加元素的顺序与排序方法、删除与修改节点操作，以及展示了Java代码实现。通过实例演示了如何使用add(), addByOrder(), delete(), update()和display()方法操作链表。
摘要由CSDN通过智能技术生成

链表

单链表介绍

链表的真实结构

单链表在内存中的结构

结构分析

从结构图中可以分析出

  1. 链表是以节点的方式来存储值
  2. 每一个节点包含了值和next节点
  3. 链表的各个节点不一定是连续存储的
  4. 链表分为带头节点的链表和不带头节点的链表

链表的逻辑结构

单链表的逻辑结构

单链表的代码实现

分析节点属性

  1. 数据属性（如姓名，大招技能等）
  2. 下一节点next（故其属性是一个节点！）
 class Node {
    public int no;
    public String name;
    public String big;
    //注意node节点中next的属性！！！！
    public Node next;

    public Node(int no, String name, String big) {
        this.no = no;
        this.name = name;
        this.big = big;
    }

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

添加元素的方法add()（顺序添加,只能插在链表的尾部）

  1. 通过死循环来遍历，要找一个临时的指针temp，来遍历整个链表，因为要找到最后一个节点，进行插值。
  2. 如果找到最后一个节点位置，则直接进行跳出循环进行插值
  3. 如果没有找到最后一个节点，则在循环中进行指针指向下一个节点的操作
 //添加节点的方法，采用顺序插入法，将新的节点插到最后一个位置，故肯定是要遍历出最后一个节点，来存放这个数据
    public void add(Node node) {
        //由于头节点不能动，故要设置一个临时节点来遍历，从而找到最后一个节点
        Node temp = head;
        //通过死循环找出最后一个节点
        while (true) {
            if (temp.next == null) {
                break;
            }
            //如果不是最后一个节点，就找下一个
            temp = temp.next;
        }
        //找到最后一个节点之后，将新的插入节点赋值到最后一个节点上
        temp.next = node;
    }

添加元素的方法addByOrder()（可以判断no的值来排序）

排序插入的图解
通过以上图，当新的节点值为4时，通过temp指针判断要插入的位置。因为要按照顺序插入，需要两步：

  1. node.next=temp.next
  2. temp.next=node
 //通过顺序加入
    public void addByOrder(Node node) {
        //还是要引入辅助变量
        Node temp = head;
        //此标记用来判断所添加的元素是否已经存在
        boolean flag = false;
        //遍历整个链表
        while (true) {
            if (temp.next == null) {
                break;
            }
            //找到要插入节点的位置
            if (temp.next.no > node.no) {
                break;
            } else if (temp.next.no == node.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }

        if (flag) {
            System.out.println("准备插入的人编号【" + node.no + "】已存在");
        } else {
            //若可以插入，则将新的节点插入
            node.next = temp.next;
            temp.next = node;
        }
    }

删除节点的方法delete()

删除节点的图解
如图，想要删除一个节点步骤：

  1. 首先确定要删除节点的前一个位置即temp。
  2. 找到位置之后，只需要让temp.next=temp.next.next就可以实现删除节点的操作。
  3. 没有引用的节点，会被垃圾回收机制回收掉。
public void delete(int no){
        Node 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;
            System.out.println("编号为【"+no+"】的英雄删除成功！");
        }else {
            System.out.println("编号为【"+no+"】的英雄不存在！");
        }
    }

修改节点的方法update()

在这里插入图片描述

public void update(Node newNode){
        Node temp=head;
        //表示链表中是否存在该节点
        boolean flag=false;
        while(true){
            if(temp==null){
                break;
            }
            if(temp.no==newNode.no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if(flag){
            temp.name=newNode.name;
            temp.big=newNode.big;
            System.out.println("修改成功！");
        }else {
            System.out.println("没有找到编号为["+newNode.no+"]的节点");
        }
    }

显示元素的方法display()

  1. 首先判断链表是否为空，若为空，可以直接返回
  2. 通过死循环来遍历整个链表进行输出，如果找到最后一个节点，则跳出死循环
    //显示链表中的节点,同是需要找一个；临时指针来遍历链表
    public void display() {
        //首先判断链表是否为空
        if (head.next == null) {
            return;
        }
        Node temp = head.next;
        //遍历每一个链表
        while (true) {
            //如果下一个节点为空，说明已经找到了最后一个节点，可以退出
            if (temp == null) {
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }

代码测试

package com.njupt.List;

/**
 * Creat with IntelliJ IDEA
 *
 * @Auther:倔强的加瓦
 * @Date:2021/07/13/11:32
 * @Description:
 */
public class LinkedListDemo {
    public static void main(String[] args) {
        Node node1 = new Node(1, "花木兰", "推推");
        Node node2 = new Node(2, "张飞", "变大");
        Node node3 = new Node(3, "牛魔", "起飞");
        Node node4 = new Node(4, "鲁班", "等死");
        SingList singList = new SingList();
        System.out.println("使用有序插入：");
        singList.add(node1);
        singList.add(node2);
        singList.add(node4);
        singList.add(node3);
        singList.display();
        //测试修改英雄
        Node node5 = new Node(4, "鲁班", "起飞升天");
        singList.update(node5);
        singList.display();

        System.out.println("------删除-------");
        singList.delete(1);
        singList.display();
        System.out.println("------删除-------");

        SingList singList1 = new SingList();
        System.out.println("使用无序插入：");
        singList1.addByOrder(node1);
        singList1.addByOrder(node2);
        singList1.addByOrder(node4);
        singList1.addByOrder(node3);
        singList1.display();

    }
}

//2创建链表来管理对象
class SingList {
    //头节点不存放数据，并且不能动
    private Node head = new Node(0, "", "");

    //添加节点的方法，采用顺序插入法，将新的节点插到最后一个位置，故肯定是要遍历出最后一个节点，来存放这个数据
    public void add(Node node) {
        //由于头节点不能动，故要设置一个临时节点来遍历，从而找到最后一个节点
        Node temp = head;
        //通过死循环找出最后一个节点
        while (true) {
            if (temp.next == null) {
                break;
            }
            //如果不是最后一个节点，就找下一个
            temp = temp.next;
        }
        //找到最后一个节点之后，将新的插入节点赋值到最后一个节点上
        temp.next = node;
    }

    //通过顺序加入
    public void addByOrder(Node node) {
        //还是要引入辅助变量
        Node temp = head;
        //此标记用来判断所添加的元素是否已经存在
        boolean flag = false;
        //遍历整个链表
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no > node.no) {
                break;
            } else if (temp.next.no == node.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }

        if (flag) {
            System.out.println("准备插入的人编号【" + node.no + "】已存在");
        } else {
            //若可以插入，则将新的节点插入
            node.next = temp.next;
            temp.next = node;
        }
    }
    //修改节点信息的方法
    public void update(Node newNode){
        Node temp=head;
        //表示链表中是否存在该节点
        boolean flag=false;
        while(true){
            if(temp==null){
                break;
            }
            if(temp.no==newNode.no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if(flag){
            temp.name=newNode.name;
            temp.big=newNode.big;
            System.out.println("修改成功！");
        }else {
            System.out.println("没有找到编号为["+newNode.no+"]的节点");
        }
    }

    public void delete(int no){
        Node 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;
            System.out.println("编号为【"+no+"】的英雄删除成功！");
        }else {
            System.out.println("编号为【"+no+"】的英雄不存在！");
        }
    }

    //显示链表中的节点,同是需要找一个；临时指针来遍历链表
    public void display() {
        //首先判断链表是否为空
        if (head.next == null) {
            return;
        }
        Node temp = head.next;
        //遍历每一个链表
        while (true) {
            //如果下一个节点为空，说明已经找到了最后一个节点，可以退出
            if (temp == null) {
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }
}

//1创建节点对象
class Node {
    public int no;
    public String name;
    public String big;
    public Node next;

    public Node(int no, String name, String big) {
        this.no = no;
        this.name = name;
        this.big = big;
    }

    @Override
    public String toString() {
        return "Node{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", big='" + big + '\'' +
                '}';
    }
}
倔强的加瓦
关注
专栏目录
单向链表之增删改查
qq_36273886的博客
08-12 280
单项链表实现增删改啥 思路分析： 该算法的核心在于对链表的数据操控，借助指针，实现对数据的增删改啥，其实是next地址的修改 因为是单向链表，所以进行操作时候，辅助节点（指针）必须位于要操作元素的前一个节点（遍历可以是每个元素的本身） 1.带头节点的单向链表，元素节点分为data域和next域，将next域指向下一个节点的地址 2.创建指针temp，通过指针移动来读取各个节点的元素 3.添加，更新，删除，查看的逻辑，指针的向后移动来进行增删改查 1.新增 1.不做逻辑判断，向...
python 链表——单向链表的增、删、改、查
sinceNow的博客
08-01 603
单向链表 单向链表的节点实现 class SingleNode(object): """单链表的节点""" def __init__(self, item): self.item = item self.next = None 单链表的操作 ​​​​is_empty() #链表是否为空 length() # 链表长度 trave...
【单链表】单链表的增删改查
热爱编程的菜鸟
11-01 683
链表（Linked List) 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 单链表(single LinkedList） 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继
单链表的增删改查（数据结构）
最新发布
m0_62048999的博客
09-29 1560
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
单链表的增删改查
程序猿阿蛮
07-09 217
除了尾部添加的方式，其他的增删改都需要找到前一个节点进行操作。 在有头结点的链表中，头节点不能改变。 // 定义一个链表管理节点 class SingleLinkedList { private Node headNode = new Node(0,"head"); // 1、尾部添加 public void add(Node node){ // 由于不能修改头节点，创建临时节点 Node temp = headNode; w.
【数据结构】—— 单链表的增删改查
周小末天天开心的博客
11-22 1840
单链表的创建、删除、更改、查看
单链表之增删改查
wangke的博客
03-20 294
1.java中构造方法的含义： 一个与当前类同名的方法成为构造方法。 构造方法的特点： 1、与当前类同名； 2、没有返回值； 3.一旦自定义构造方法后，系统将不再自动生成无参数的构造方法； 4.不能加void定义类型，它的无返回值与void不同，若用void定义类型，则系统不会将其认定为构造方法，即不会再需要时自动调用 构造方法的作用： 在类的实例对象刚产生时，该类中的构造方法将会被自动调用，我...
有关单向链表的增删改查
11-06
本主题将深入探讨单向链表的增、删、改、查操作。 ### 增加节点 增加节点通常涉及到在链表的特定位置插入新的节点。在单向链表中，插入操作有以下四种常见情况： 1. **头部插入**：在链表的开始处添加新节点。这...
单向链表增删改查的c代码
09-19
以下是C语言中对单向链表进行增删改查的基本操作示例： ```c // 定义链表节点结构体 typedef struct Node { int data; // 节点的数据 struct Node* next; // 指向下一个节点的指针 } Node; // 创建新节点函数 ...
用c语言实现链表增删改查
11-07
链表的主要类型包括单向链表、双向链表和循环链表等。 ### 二、代码解析 #### 1. 结构体定义 ```c struct Student { char name[12]; char sno[12]; int score; Student* next; }; ``` 这里定义了一个名为`...
用C++类实现单向链表的增删查和反转操作方法
12-31
今天用了一下午时间终于独立完成了链表操作。 找网上的代码，大多用了结构体，还有些并不适合刚学c++或者数据结构的人看，于是我是用类写的，代码比较符合学生的习惯和水平。 先看类定义 class node { public: int...
链表——单向链表的增删改查
LeeBlog
09-03 320
【目的】 实现单向链表的修改、删除操作 【代码实现】 链表的定义 //定义链表 class SingleLinkedList2{ //初始化一个头结点 private HeroNode head = new HeroNode(0,"" , ""); //添加结点 public void add(HeroNode heroNode) { HeroNode temp...
单链表增删改查
Mr.yang的博客
03-08 556
单链表节点类链表类插入到最后按顺序插入（完成后，链表有序）更新节点删除节点单链表反转 节点类 class Node{ public int id; public String name; public Node next; //指向下一个节点 public Node() { } public Node(int id, String name...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值