＜数据结构＞链表的增删改------java实现

最新推荐文章于 2023-08-05 18:41:59 发布
最新推荐文章于 2023-08-05 18:41:59 发布
阅读量154 收藏 1
点赞数
分类专栏： 数据结构 Java 文章标签： 链表 数据结构 java 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44830106/article/details/115602083
版权

1、定义结点Node

这里结点的数据域是(int,String,String)
下一节点next统一初始化为null
并且提供一个有参构造函数public Node(int no,String name,String nickName)
为了方便实例输出，还重写了方法toString()

class Node
{
    //数据域
    int no;
    String name;
    String nickName;
    //下一节点
    Node next=null;

    //构造器
    public Node(int no,String name,String nickName)
    {

        this.no=no;
        this.name=name;
        this.nickName=nickName;
    }
    //为了显示方便，重写toString()
    @Override
    public String toString() {
        return "Node{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '}';
    }
}

2、链表的总体结构

首先是定义一个头结点head，后续的增删改操作都是得通过head来实现的，但是并不是以head来遍历操作，而是为其创建一个副本来操作，因为需要根据头结点head来找到这个链表，因此不能修改head相关的值，应该是为其创建副本
方法 add(Node node) 是直接在链表的结尾添加新结点
方法 addByOrder(Node node) 是根据结点的数据域中的no值来按顺序添加结点
方法 printList() 是输出链表的值
方法 update(Node node,int pos) 是根据下标pos(由0开始)来更改结点，将下标为pos的结点修改为node
方法 delete(int pos) 是根据下标pos(由0开始)来删除结点
在这里插入图片描述

3、在链表尾部添加结点

    public void add(Node node)
    {
        //找到最后一个结点，将其next域指向新结点即可
        //由于head不能修改，因此需要一个辅助指针
        Node temp=head;
        //遍历链表找到最后一个结点
        while(true)
        {
            if(temp.next==null)
            {
                break;
            }
            else
            {
                //后移
                temp=temp.next;
            }
        }
        //当退出循环时，此时temp即链表的最后一个结点，使temp指向新的结点
        temp.next=node;
        node.next=null;
    }

4、根据结点数据域中的no值来添加结点

    public void addByOrder(Node node)
    {
        Node pNode=head;
        if(null==head.next)
        {
            add(node);
        }
        else
        {
            /*找到符合插入位置的前一个结点pNode,判断node与pNode.next之间的关系
            若pNode.next.no<=node.no,那么还得接着往后找
            若pNode.next.no>node.no,那么就找到了位置,修改
            node.next=pNode.next;  pNode.next=node;*/
            while(pNode.next!=null)
            {
                if(pNode.next.no>node.no)
                {
                    node.next=pNode.next;
                    pNode.next=node;
                    return;  //添加完毕，直接退出
                }
                pNode=pNode.next;
            }
            if(pNode.next==null)
            {
                add(node);  //如果到了这一步，说明其值是最大的，直接在结尾添加
            }
        }
    }

5、更新结点

    public void update(Node node,int pos)
    {
        Node pNode=head.next;
        int i=0;
        //寻找修改的位置，若位置超过链表长度或者链表初始长度为0，那么不会经过此循环
        while(i<pos && pNode!=null)
        {
            i++;
            pNode=pNode.next;
        }
        if(i==pos && pNode!=null)   //i能到达pos且此结点不是不存在的结点，则能修改
        {
            pNode.no=node.no;
            pNode.name=node.name;
            pNode.nickName=node.nickName;
            System.out.printf("修改位置%d的结点成功\n",i);
        }
        else
        {
            System.out.printf("修改位置%d的结点失败\n",i);
        }
    }

6、删除结点

    public void delete(int pos)  //找到待删除结点的前一个结点
    {
        Node pNode=head;
        boolean flag=false;
        int i=-1;
        while(true)  //退出条件为到达找到待删除结点的前一个结点位置,或者是到达最后一个结点，到达最后一个结点说明无法删除该元素
        {
            if(pNode.next==null)    //先判断位置是否合理再判断是否为待删除结点的前一个位置，否则会出现pNode.next.next的空指针报错
            {
                //说明是遍历到最后一个位置了，说明删除的位置有问题
                System.out.println("删除位置有问题");
                break;
            }

            else if (i+1 == pos)
            {
                Node temp = pNode.next;
                pNode.next = pNode.next.next;
                flag=true;
                System.out.println("删除结点成功,结点为" + temp.toString());
                break;
            }
            else
            {
                //继续遍历
                pNode=pNode.next;
                i++;
            }
        }

    }

7、打印链表

    public void printList()
    {
        if(head.next==null)
        {
            //说明此时链表中无任何元素
            return;  //退出此方法
        }
        Node tempHead=head.next;//指向链表的第一个元素
        while(tempHead!=null)
        {
            System.out.println(tempHead.toString());
            tempHead=tempHead.next;

        }
    }

8、测试样例

public class MyLinkedList {


    public static void main(String args[])
    {
        Node node1=new Node(1,"宋江","及时雨");
        Node node2=new Node(2,"卢俊义","玉麒麟");
        Node node3=new Node(3,"吴用","智多星");
        Node node5=new Node(3,"武松","智多星");
        Node node4=new Node(4,"林冲","豹子头");

        //创建链表
        linkedList L=new linkedList();
        L.addByOrder(node1);
        L.addByOrder(node4);
        L.addByOrder(node3);
        L.addByOrder(node2);
        L.addByOrder(node5);
        //显示
        L.printList();
        System.out.println("------------------------------------修改节点-------------------------------------------");
        L.update(new Node(10,"小林","木木"),3);
        System.out.println("修改后的链表:");
        L.printList();
        L.update(new Node(9,"赵明","小明"),0);
        System.out.println("修改后的链表:");
        L.printList();
        L.update(new Node(8,"张三","小张"),4);
        System.out.println("修改后的链表:");
        L.printList();
        L.update(new Node(7,"李四","小李"),5);
        System.out.println("修改后的链表:");
        L.printList();
        System.out.println("------------------------------------删除节点-------------------------------------------");
        for(int i=4;i>=0;i--)
        {
            L.delete(i);
            System.out.println("删除后的链表");
            L.printList();
        }
    }

}

运行结果：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

源代码：

package linkedList;


class Node
{
    //数据域
    int no;
    String name;
    String nickName;
    //下一节点
    Node next=null;

    //构造器
    public Node(int no,String name,String nickName)
    {

        this.no=no;
        this.name=name;
        this.nickName=nickName;
    }
    //为了显示方便，重写toString()
    @Override
    public String toString() {
        return "Node{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '}';
    }
}

//定义一个链表
class linkedList
{
    //初始化一个头结点，并且之后都不要对其进行修改，因为要靠这个头结点访问后续的结点
    private Node head=new Node(0,"","");

    //添加结点到链表
    public void add(Node node)
    {
        //找到最后一个结点，将其next域指向新结点即可
        //由于head不能修改，因此需要一个辅助指针
        Node temp=head;
        //遍历链表找到最后一个结点
        while(true)
        {
            if(temp.next==null)
            {
                break;
            }
            else
            {
                //后移
                temp=temp.next;
            }
        }
        //当退出循环时，此时temp指向新的结点
        temp.next=node;
        node.next=null;
    }
    public void addByOrder(Node node)
    {
        Node pNode=head;
        if(null==head.next)
        {
            add(node);
        }
        else
        {
            /*找到符合插入位置的前一个结点pNode,判断node与pNode.next之间的关系
            若pNode.next.no<=node.no,那么还得接着往后找
            若pNode.next.no>node.no,那么就找到了位置,修改
            node.next=pNode.next;  pNode.next=node;*/
            while(pNode.next!=null)
            {
                if(pNode.next.no>node.no)
                {
                    node.next=pNode.next;
                    pNode.next=node;
                    return;  //添加完毕，直接退出
                }
                pNode=pNode.next;
            }
            if(pNode.next==null)
            {
                add(node);  //如果到了这一步，说明其值是最大的，直接在结尾添加
            }
        }
    }
    public void printList()
    {
        if(head.next==null)
        {
            //说明此时链表中无任何元素
            return;  //退出此方法
        }
        Node tempHead=head.next;//指向链表的第一个元素
        while(tempHead!=null)
        {
            System.out.println(tempHead.toString());
            tempHead=tempHead.next;

        }
    }
    public void update(Node node,int pos)
    {
        Node pNode=head.next;
        int i=0;
        //寻找修改的位置，若位置超过链表长度或者链表初始长度为0，那么不会经过此循环
        while(i<pos && pNode!=null)
        {
            i++;
            pNode=pNode.next;
        }
        if(i==pos && pNode!=null)   //i能到达pos且此结点不是不存在的结点，则能修改
        {
            pNode.no=node.no;
            pNode.name=node.name;
            pNode.nickName=node.nickName;
            System.out.printf("修改位置%d的结点成功\n",i);
        }
        else
        {
            System.out.printf("修改位置%d的结点失败\n",i);
        }
    }
    public void delete(int pos)  //找到待删除结点的前一个结点
    {
        Node pNode=head;
        boolean flag=false;
        int i=-1;
        while(true)  //退出条件为到达找到待删除结点的前一个结点位置,或者是到达最后一个结点，到达最后一个结点说明无法删除该元素
        {
            if(pNode.next==null)    //先判断位置是否合理再判断是否为待删除结点的前一个位置，否则会出现pNode.next.next的空指针报错
            {
                //说明是遍历到最后一个位置了，说明删除的位置有问题
                System.out.println("删除位置有问题");
                break;
            }

            else if (i+1 == pos)
            {
                Node temp = pNode.next;
                pNode.next = pNode.next.next;
                flag=true;
                System.out.println("删除结点成功,结点为" + temp.toString());
                break;
            }
            else
            {
                //继续遍历
                pNode=pNode.next;
                i++;
            }
        }

    }

}

public class MyLinkedList {


    public static void main(String args[])
    {
        Node node1=new Node(1,"宋江","及时雨");
        Node node2=new Node(2,"卢俊义","玉麒麟");
        Node node3=new Node(3,"吴用","智多星");
        Node node5=new Node(3,"武松","智多星");
        Node node4=new Node(4,"林冲","豹子头");

        //创建链表
        linkedList L=new linkedList();
        L.addByOrder(node1);
        L.addByOrder(node4);
        L.addByOrder(node3);
        L.addByOrder(node2);
        L.addByOrder(node5);
        //显示
        L.printList();
        System.out.println("------------------------------------修改节点-------------------------------------------");
        L.update(new Node(10,"小林","木木"),3);
        System.out.println("修改后的链表:");
        L.printList();
        L.update(new Node(9,"赵明","小明"),0);
        System.out.println("修改后的链表:");
        L.printList();
        L.update(new Node(8,"张三","小张"),4);
        System.out.println("修改后的链表:");
        L.printList();
        L.update(new Node(7,"李四","小李"),5);
        System.out.println("修改后的链表:");
        L.printList();
        System.out.println("------------------------------------删除节点-------------------------------------------");
        for(int i=4;i>=0;i--)
        {
            L.delete(i);
            System.out.println("删除后的链表");
            L.printList();
        }
    }

}
小李子还挺酸
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
头歌 数据结构 第二关 顺序表的实现之增删功能
m0_73938781的博客
04-23 790
【代码】头歌 数据结构 第二关 顺序表的实现之增删功能。
educoder数据结构链表及其应用
qq_49826354的博客
03-27 4766
educoder数据结构链表及其应用第一题第二题第三题 第一题 void LL_GetAt(LinkList L, int i, ElemType &e) // 在带头结点的单链表L中获取第i个元素的值赋给e，i的取值范围[1,n] { // 请在这里补充代码，完成本关任务 /********** Begin *********/ LNode* p; p = L ->next; int j = 1; while (i > j && p) { p =
7-数据结构-（带头节点）单链表的增删改查
奔心小韩的博客
08-05 878
带头节点单链表的增删改查
链表实现增删查改
zhengyawen666的博客
04-26 1163
一 链表的特点 1 按需申请空间 由于每一块物理空间都是单独申请的，因此需要考虑如何关联每一个内存块 -》用指针关联（每个节点存放两个东西：内容和指向下一个内存块的指针） 相比于顺序表空间浪费较小：一次开辟两倍，过多浪费；频繁开辟那么频繁访问内存，效率低下。 2 效率更高 头部或者中间插入删除，不需要挪动数据（顺序表需要），相对于顺序表效率更高，因为顺序表再头部或者中间插入的话，需要挪动数据。 总结：链表与顺序表优势互补，各有特点。 二 链表的结构 对于单向不循环链表 每个节点包括所
Educoder头歌数据结构链表及其应用
热门推荐
qq_50848214的博客
11-05 1万+
头歌实践平台答案educoder 数据结构-链表及其应用 第1关：链表的实现之查找功能 /************************************************************* 链表的实现之查找功能 实现文件 更新于2020年4月21日 **************************************************************/ void LL_GetAt(LinkList L, int i, ElemType &amp
【Java实现链表的增删改查】
leach
03-20 727
数据结构之链表 1.数据的增加分为头插和尾插和中间插入： 头插：令每一个进来的新节点的next为指向头，然后改头为新节点 尾插：令Current+1的节点为新节点 中间插入：找到你想插入的位置的前一个节点，让这个新结点的next->前一个节点的后一个节点，再让前一个节点指向新节点 public void add(int data,int index) { if (head == null) { head = new Node(data, null);
java数据结构之链表（增删改查等操作）
java编程学习_java基础教程_booyzhang的博客
05-06 431
在链表中，需要使用到递归算法 递归算法： 一种直接或间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。 递归实例： public class JiechengTest{ public static void main(String[] args){ //int result = jiecheng1(5); int re...
Java用数组和链表的方式简单实现HashMap的增删改功能 数组和链表.pdf
04-18
在Java中，HashMap的实现方式有多种，本文将介绍使用数组和链表的方式简单实现HashMap的增删改功能。 HashMap的数据结构 HashMap的数据结构主要由三个部分组成：数组、链表和红黑树。数组用于存储键值对，链表用于...
【Java面试资料】-蚂蚁金服面试题总结
08-16
12. **算法与数据结构**：虽然Java面试不直接考算法，但高效的算法思维和常见数据结构（如链表、树、图、堆、队列、栈等）的应用能力是评估程序员解决问题能力的重要指标。 这份“【Java面试资料】-蚂蚁金服面试题...
50个必会的数据结构及算法实现源码
12-14
问题：实现一个大小固定的有序数组，支持动态增删改操作 问题：实现两个有序数组合并为一个有序数组 链表 问题：实现单链表、循环链表、双向链表，支持增删操作 问题：实现单链表反转 问题：实现两个有序的链表...
头歌数据结构单链表的基本操作
05-18
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 顺序表是线性表的顺序存储结构的别称，特点是以“存储位置相邻”表示两个元素之间的前驱、后继关系。 优点：是可以随机存取表中任意一个元素。 缺点：是每作一次插入或删除操作时，平均来说必须移动表中一半元素。 常应用于主要是为查询而很少作插入和删除操作，表长变化不大的线性表。 链表是线性表的链式存储结构的别称，特点是以“指针”指示后继元素，因此线性表的元素可以存储在存储器中任意一组存储单元中。 优点：是便于进行插入和删除操作。 缺点：是不能进行随机存取，每个元素的存储位置都存放在其前驱元素的指针域中，为取得表中任意一个数据元素都必须从第一个数据元素起查询。 由于链表是一种动态分配的结构，结点的存储空间可以随用随取，并在删除结点时随时释放，以便系统资源更有效地被利用。
剑指offer（java版）----牛客.zip
09-20
1. 数据结构基础： - 数组：理解数组的原理，包括一维数组、二维数组，以及如何高效地操作数组。 - 链表：掌握单链表、双链表的操作，如插入、删除、反转等。 - 栈和队列：了解它们的基本概念和实现，如用数组或...
数据结构和算法必知必会的50个代码实现.zip
最新发布
05-11
【数据结构课程设计】 数组 实现一个支持动态扩容的数组 实现一个大小固定的有序数组，支持动态增删改操作 实现两个有序数组合并为一个有序数组 链表 实现单链表、循环链表、双向链表，支持增删操作 实现单链表...
链表的增删查改功能的实现
MacondoMayor的博客
04-05 2513
链表增删改查功能的实现
链表的实现，增删改
weixin_46048110的博客
03-16 1477
package com.zhen.linkedlist; public class SingleLinkedListDemo { public static void main(String[] args) { HeroNode heroNode1 = new HeroNode(1, "宋江", "及时雨"); HeroNode heroNode2 = new HeroNode(2, "卢俊义", "玉麒麟"); HeroNode heroNode.
数据结构：链表实现增删查改的基本功能【内含详细代码，建议收藏】
weixin_53472920的博客
09-15 2516
hello，大家好，这期文章继续用来更新数据结构方面的知识——链表。。这期文章依旧是对之前的文章[数据结构：红玫瑰与白玫瑰之争](https://blog.csdn.net/weixin_53472920/article/details/115463675)的补充，希望对大家有所帮助。我们在之前的文章中已经介绍过顺序表，链表和顺序表有很大的不同，相对于顺序表，链表无疑是更加灵活的。顺序表在实现过程中头部插入数据时需要挪动数据，在增容的过程中也会消耗性能，并且以倍数的方式增容也会造成空间的浪费。链表 ...
实现链表的创建并对链表进行增、删、改、查等功能
qq_56395437的博客
07-28 357
实现链表的创建并对链表进行增、删、改、查等功能
【数据结构】链表-增删查改
weixin_44930735的博客
07-31 2517
链表是一种物理结构上非连续、非顺序的存储结构，数据元素的逻辑是通过链表中的指针链接次序实现的。 链表创建完成后不需要初始化，链表过于简单，就是由一个个的结构体通过指针域串起来的，在不存储数据的时候，可以没有任何节点，即没有结构体，在主函数中将指向结构体的指针置为空就行了。......
＜Java＞lambda表达式及使用parallelStream().filter()过滤数据
小李子还挺酸的博客
08-24 5696
1、lambda表达式特征 * 1、可选类型声明：不需要声明参数类型，编译器可以统一识别参数值 * 2、可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号 x -> x*2 接收一个参数，并且返回其2倍的数值 * 3、可选的大括号：如果主体包含了一个语句，就不需要使用大括号 * 4、可选的返回关键字：如果主体只有一个表达式返回值，那么编译器会自动返回值，大括号需要指明表达式返回了一个数值 * * 1、不需要参数，返回值为5 * () -> 5 * * 2、
p->next->score<p1->next->score
07-09
这个表达式是用来比较两个链表节点的分数大小。假设p和p1都是指向链表节点的指针，那么p->...所以，p->next->score < p1->next->score表示如果p节点的下一个节点的分数小于p1节点的下一个节点的分数，这个条件成立。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值