单链表的实现与增删改查

最新推荐文章于 2023-11-10 16:05:51 发布
最新推荐文章于 2023-11-10 16:05:51 发布
阅读量134 收藏
点赞数 1
分类专栏： java 链表 数据结构 文章标签： 链表 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaojiejie01/article/details/108190072
版权
java 同时被 3 个专栏收录
3 篇文章 0 订阅
订阅专栏
链表
1 篇文章 0 订阅
订阅专栏
数据结构
1 篇文章 0 订阅
订阅专栏

单链表的实现与CRUD


@一只大狗头

单链表的实现与增删改查

单链表的实现
欢迎探讨【狗头】

链表实现

1.准备

 class Hero{
             public int id;
             public String name;
             public String otherName;
             public Hero next;
             public Hero(int id, String name, String otherName){
                 this.id = id;
                 this.name = name;
                 this.otherName = otherName;
             }

           @Override
           public String toString() {
               return "Hero{" +
                       "id=" + id +
                       ", name='" + name + '\'' +
                       ", otherName='" + otherName + '\'' +
                       '}';
           }
       }

2.增（不能实现随机输入还能顺序输出）

 class SingleLinklist{
              private Hero head = new Hero(0,"","");
              //第一种增加
              public void add(Hero hero){
                 Hero temp = head;
                 while (true){
                     if(temp.next == null){
                         break;
                     }
                     temp = temp.next;
                 }
                 temp.next = hero;
             }
             }

.增（能实现随机输入还能顺序输出）

 //第二种方式按顺序写入
           public void addByorder(Hero hero){
                  Hero temp = head;
                  boolean flag = false;
                  while (true){
                      if(temp.next == null){
                          break;
                      }
                      if(temp.next.id > hero.id){
                          break;
                      }else if(temp.next.id == hero.id){
                          flag = true;
                          break;
                      }
                      temp = temp.next;
                  }
                  if(flag){
                      System.out.printf("准备插入的英雄编号%d已经存在，不能加入\n",hero.id);
                  }else {
                      hero.next = temp.next;
                      temp.next = hero;
                  }
           }

3.删

public void delete(int id){
                  Hero temp = head;
                  boolean bool = false;
                  while(true){
                      if(temp.next == null){
                          break;
                      }
                      if(temp.next.id == id){
                          bool = true;
                          break;
                      }
                      temp = temp.next;
                  }
                  if(bool){
                      temp.next = temp.next.next;

                  }else {
                      System.out.printf("要删除的%d节点不存在\n");
                  }
             }

4.改

//更新
             public void update(Hero newhero){
                  Hero temp = head.next;
                  boolean bool = false;
                  if(head.next == null){
                      System.out.println("链表为空");
                      return;
                  }
                  while (true){
                      if(temp == null){
                          break;
                      }
                      if(temp.id == newhero.id){
                          bool = true;
                          break;
                      }
                      temp = temp.next;
                  }
                 if(bool){
                     temp.name = newhero.name;
                     temp.otherName = newhero.otherName;
                 }else {
                     System.out.printf("没有找到该%d编号的信息",newhero.id);
                 }
             }

5.查

 //查询
             public void seekByid(int id){
                  Hero temp = head;
                  boolean bool = false;
                  while (true){
                      if(temp.next == null){
                          break;
                      }
                      if(temp.next.id == id){
                         bool = true;
                         break;
                      }
                      temp = temp.next;
                  }
                  if(bool){
                      System.out.printf("要查询的编号为%d号的信息为:",id);
                      System.out.println(temp.next);
                  }else {
                      System.out.println("没有查到信息");
                  }
             }

6.显示全部数据

//显示所有数据
             public void list(){
                  if(head.next == null){
                      System.out.println("链表为空");
                      return;
                  }
                  Hero temp = head.next;
                  while (true){
                      if(temp == null){
                          break;
                      }
                      System.out.println(temp);
                      temp = temp.next;
                  }

             }

7.测试（因为懒选择手动调试）：

public static void main(String[] args) {
        Hero hero1 = new Hero(1, "dog1", "aadog1");
        Hero hero2 = new Hero(2, "dog2", "aadog2");
        Hero hero3 = new Hero(3, "dog3", "aadog3");
        Hero hero4 = new Hero(4, "dog4", "aadog4");
        //测试
        SingleLinklist singleLinklist = new SingleLinklist();
        //按顺序增加
        singleLinklist.add(hero1);
        singleLinklist.add(hero2);
        singleLinklist.add(hero3);
        singleLinklist.add(hero4);
        singleLinklist.list();
        System.out.println("----------------------");

        //不按顺序增加
        singleLinklist.addByorder(hero1);
        singleLinklist.addByorder(hero4);
        singleLinklist.addByorder(hero3);
        singleLinklist.addByorder(hero2);
        singleLinklist.list();
        System.out.println("-----------------------");
        //
        //更新链表
        Hero newhero2 = new Hero(2, "bigdog2", "dog2");
        singleLinklist.update(newhero2);
        singleLinklist.list();
        System.out.println("--------------------------");
        //
        //删除链表
        singleLinklist.delete(2);
        singleLinklist.list();
        //
        //查找链表数据
        System.out.println("--------------------------");
        singleLinklist.seekByid(3);


    }

结果：
Hero{id=1, name=‘dog1’, otherName=‘aadog1’}
Hero{id=2, name=‘dog2’, otherName=‘aadog2’}
Hero{id=3, name=‘dog3’, otherName=‘aadog3’}
Hero{id=4, name=‘dog4’, otherName=‘aadog4’}

准备插入的英雄编号1已经存在，不能加入
准备插入的英雄编号4已经存在，不能加入
准备插入的英雄编号3已经存在，不能加入
准备插入的英雄编号2已经存在，不能加入
Hero{id=1, name=‘dog1’, otherName=‘aadog1’}
Hero{id=2, name=‘dog2’, otherName=‘aadog2’}
Hero{id=3, name=‘dog3’, otherName=‘aadog3’}
Hero{id=4, name=‘dog4’, otherName=‘aadog4’}

Hero{id=1, name=‘dog1’, otherName=‘aadog1’}
Hero{id=2, name=‘bigdog2’, otherName=‘dog2’}
Hero{id=3, name=‘dog3’, otherName=‘aadog3’}
Hero{id=4, name=‘dog4’, otherName=‘aadog4’}

Hero{id=1, name=‘dog1’, otherName=‘aadog1’}
Hero{id=3, name=‘dog3’, otherName=‘aadog3’}
Hero{id=4, name=‘dog4’, otherName=‘aadog4’}

要查询的编号为3号的信息为:Hero{id=3, name=‘dog3’, otherName=‘aadog3’}

附录##完整代码：

/**
 * @Author big dog
 * Date on 2020/8/23  14:16
 */
public class Linklist {
    public static void main(String[] args) {
        Hero hero1 = new Hero(1, "dog1", "aadog1");
        Hero hero2 = new Hero(2, "dog2", "aadog2");
        Hero hero3 = new Hero(3, "dog3", "aadog3");
        Hero hero4 = new Hero(4, "dog4", "aadog4");
        //测试
        SingleLinklist singleLinklist = new SingleLinklist();
        //按顺序增加
        singleLinklist.add(hero1);
        singleLinklist.add(hero2);
        singleLinklist.add(hero3);
        singleLinklist.add(hero4);
        singleLinklist.list();
        System.out.println("----------------------");

        //不按顺序增加
        singleLinklist.addByorder(hero1);
        singleLinklist.addByorder(hero4);
        singleLinklist.addByorder(hero3);
        singleLinklist.addByorder(hero2);
        singleLinklist.list();
        System.out.println("-----------------------");
        //
        //更新链表
        Hero newhero2 = new Hero(2, "bigdog2", "dog2");
        singleLinklist.update(newhero2);
        singleLinklist.list();
        System.out.println("--------------------------");
        //
        //删除链表
        singleLinklist.delete(2);
        singleLinklist.list();
        //
        //查找链表数据
        System.out.println("--------------------------");
        singleLinklist.seekByid(3);


    }
}

       class Hero{
             public int id;
             public String name;
             public String otherName;
             public Hero next;
             public Hero(int id, String name, String otherName){
                 this.id = id;
                 this.name = name;
                 this.otherName = otherName;
             }

           @Override
           public String toString() {
               return "Hero{" +
                       "id=" + id +
                       ", name='" + name + '\'' +
                       ", otherName='" + otherName + '\'' +
                       '}';
           }
       }


       class SingleLinklist{
              private Hero head = new Hero(0,"","");
              //第一种增加
              public void add(Hero hero){
                 Hero temp = head;
                 while (true){
                     if(temp.next == null){
                         break;
                     }
                     temp = temp.next;
                 }
                 temp.next = hero;
             }

             //第二种方式按顺序写入
           public void addByorder(Hero hero){
                  Hero temp = head;
                  boolean flag = false;
                  while (true){
                      if(temp.next == null){
                          break;
                      }
                      if(temp.next.id > hero.id){
                          break;
                      }else if(temp.next.id == hero.id){
                          flag = true;
                          break;
                      }
                      temp = temp.next;
                  }
                  if(flag){
                      System.out.printf("准备插入的英雄编号%d已经存在，不能加入\n",hero.id);
                  }else {
                      hero.next = temp.next;
                      temp.next = hero;
                  }
           }

             //更新
             public void update(Hero newhero){
                  Hero temp = head.next;
                  boolean bool = false;
                  if(head.next == null){
                      System.out.println("链表为空");
                      return;
                  }
                  while (true){
                      if(temp == null){
                          break;
                      }
                      if(temp.id == newhero.id){
                          bool = true;
                          break;
                      }
                      temp = temp.next;
                  }
                 if(bool){
                     temp.name = newhero.name;
                     temp.otherName = newhero.otherName;
                 }else {
                     System.out.printf("没有找到该%d编号的信息",newhero.id);
                 }
             }
              //
              //删除
             public void delete(int id){
                  Hero temp = head;
                  boolean bool = false;
                  while(true){
                      if(temp.next == null){
                          break;
                      }
                      if(temp.next.id == id){
                          bool = true;
                          break;
                      }
                      temp = temp.next;
                  }
                  if(bool){
                      temp.next = temp.next.next;

                  }else {
                      System.out.printf("要删除的%d节点不存在\n");
                  }
             }

             //查询
             public void seekByid(int id){
                  Hero temp = head;
                  boolean bool = false;
                  while (true){
                      if(temp.next == null){
                          break;
                      }
                      if(temp.next.id == id){
                         bool = true;
                         break;
                      }
                      temp = temp.next;
                  }
                  if(bool){
                      System.out.printf("要查询的编号为%d号的信息为:",id);
                      System.out.println(temp.next);
                  }else {
                      System.out.println("没有查到信息");
                  }
             }


             //显示所有数据
             public void list(){
                  if(head.next == null){
                      System.out.println("链表为空");
                      return;
                  }
                  Hero temp = head.next;
                  while (true){
                      if(temp == null){
                          break;
                      }
                      System.out.println(temp);
                      temp = temp.next;
                  }

             }
       }
xiaojiejie01
关注
专栏目录
C#实现单链表的增删改查
08-08
用C#实现单链表，使用图形界面，功能有增（头插，尾插），删， 改， 能自定义节点个数，还有倒置等功能，是学习链式存储是的练习程序，多多指教，jiehanwang@126.com
【数据结构】单链表的增删查改
StandDev的博客
08-10 432
在上一节中我们提到了顺序表有如下缺陷：在头部/中间的插入与删除需要挪动数据，时间复杂度为O(N)，效率低；增容需要申请新空间，可能会拷贝数据，释放旧空间，会有不小的时间消耗；增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到 200，如果我们再继续插入了5个数据，后面没有数据插入了，那么会浪费95个数据空间；基于顺序表的这些不足，我们设计出了链表。
数据结构 - 单链表 （增删查改详解）
xiaoHu_C的博客
11-08 1408
数据结构-单链表（增删查改详解）
单链表的增删改查
ll1175555的博客
04-28 2953
#define _CRT_SECURE_NO_WARNINGS #pragma once #include <stdio.h> #include <stdlib.h> #include <assert.h> typedef int SLTDataType; typedef struct SListNode { SLTDataType data; struct SListNode* next; }SLTNode; void SListPrint(SLTNod...
数据结构-单链表的增删改查
m0_62159976的博客
04-28 162
测试函数的功能时最好写成test函数形式，不要写成菜单形式，便于调试。
Java单链表增删改查的实现
08-15
下面我们将详细探讨如何在Java中实现单链表的增、删、改、查功能，以及如何进行选择排序、冒泡排序和反转排序。 1. **单链表的定义**： - 单链表的每个节点通常包括两部分：数据域（存储元素）和指针域（存储下一...
单链表c语言实现增删改查操作
09-21
这个项目"单链表c语言实现增删改查操作"是基于VS2008运行环境，用C语言编程实现对单链表的基本操作，包括插入、删除、修改和查询元素，并将结果输出到控制台。 首先，我们需要定义链表的节点结构： ```c typedef ...
java实现单链表增删改查的实例代码详解
10-16
以上就是对单链表进行增删改查操作的详细实现。通过这些方法，我们可以对链表进行各种操作，实现对链表数据的灵活管理和处理。在实际应用中，单链表是一种非常重要的数据结构，它被广泛应用于各种算法和程序设计中。...
C语言实现单链表-增删改查.pdf
最新发布
02-16
### C语言实现单链表-增删改查 #### 一、链表基本概念与特点 链表是一种常见的线性数据结构，它由一系列节点组成，每个节点包含两部分：数据域（存放实际数据）和指针域（指向下一个节点的地址）。与数组相比，...
单链表的增删改查.c
06-18
链表是一种常见的数据结构，资源包含了我对单链表的增删改查实现，本资源是不带头结点的单链表的增删改查，个人能力有限，希望指出不足之处，与大家共勉
数据结构之带头节点的单链表增删改查操作实现
weixin_62579654的博客
07-17 1185
数据结构之带头节点的单链表增删改查操作实现
C语言实现单链表-增删改查
05-28 801
链表是由一连串节点组成的数据结构，每个节点包含一个数据值和一个指向下一个节点的指针。链表可以在头部和尾部插入和删除节点，因此可以在任何地方插入和删除节点，从而使其变得灵活和易于实现。
单链表（增删改查）【超详细】
加油！！！
11-10 3536
单链表的存储与顺序表的存储不一样，单链表不仅仅存放数值，还要存放下一个结点的地址代码//存放单链表的值//存放下一个单链表的地址}SLNode;当有了单链表的存储定义，我们就可以对单链表进行存放结点。
单链表增删查改查
wh9109的博客
03-12 225
单链表
【数据结构】—— 单链表的增删改查
周小末天天开心的博客
11-22 1821
单链表的创建、删除、更改、查看
数据结构 -2.2- 链表 | 【单链表的增删查改】
fantastic_13_7的博客
03-16 252
什么是链表、单链表的实现
【数据结构与算法】单链表的增删查改（附源码）
旋律 | 话语 | 色彩 | 情景
02-27 2426
【数据结构与算法】单链表的增删查改（附源码）
单链表（增删查改）
weixin_70056514的博客
03-07 1156
单链表是一种链式存取的数据结构，，链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示的线性表称作线性链表（单链表），单链表是链式存取的结构。简单来说单链表就是一个一个的节点链接起来的链式结构，每个节点里面存储着一个数据和与它链接的下一个节点的（指针）地址。（注意，每一个节点都是同一种结构体类型）
单链表的增、删、改、查（图解）
pjwshuai的博客
05-25 3923
C语言编程实现单链表的增、删、改、查等基本操作 ​ 二、链表和数组的区别 参考博客：链表（图文详解）_糊涂糖僧的博客-CSDN博客_链表 1、数组静态分配内存，链表动态分配内存。故链表内存利用率高，不会浪费内存，可以使用内存中细小的不连续的空间，只有在需要的时候才去创建空间。...
单链表实现增删改查c语言
04-03
#include #include struct Node { int data; struct Node* next; }; void printList(struct Node* node) { while (node !... struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));...}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值