数据结构 - 链表

最新推荐文章于 2024-07-21 14:33:09 发布
最新推荐文章于 2024-07-21 14:33:09 发布
阅读量174 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50754064/article/details/125113086
版权

基本介绍

链表是以节点的方式来存储，属于链式存储，各节点不一定是连续存储的。
每个节点包含 存放数值的data域 和 指向下一个节点的next域 。

链表的创建和遍历

思路

  1. 先创建一个头节点，表示链表的头部且后续不能更改。
  2. 后面每添加一个节点，就直接放在链表的最后。
  3. 在遍历时要创建一个新的辅助变量。

代码实现

package com.zls.demo03;

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        //先创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");

        SingleLinkedList singleLinkedList = new SingleLinkedList();
        //添加节点
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);
        //展示
        singleLinkedList.list();

    }
}

//定义单链表 用于管理英雄
class SingleLinkedList{
    //初始化头节点，不存放具体的数据
    private HeroNode head = new HeroNode(0,"","");

    //添加节点到单项链表
    public void add(HeroNode heroNode){
        //辅助遍历
        HeroNode temp = head;
        //遍历找到最后一个节点
        while (temp.next != null) {
            temp = temp.next;
        }
        //退出循环后temp指向了链表的最后
        //将最后这个节点的next指向新节点
        temp.next = heroNode;
    }

    //遍历展示链表
    public void list(){
        if (head.next == null){
            System.out.println("链表为空");
            return ;
        }
        HeroNode temp = head.next;
        while (temp != null) {
            System.out.println(temp);
            temp = temp.next;
        }
    }

}

//定义节点 每个HeroNode对象就是一个节点
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 + '\'' +
                '}';
    }
}

在这里插入图片描述

按顺序加入节点

思路

  1. 先找到要添加的节点的位置
  2. 新节点.next = temp.next
  3. temp.next = 新节点

代码实现

package com.zls.demo03;

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        //先创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");

        SingleLinkedList singleLinkedList = new SingleLinkedList();
        //添加节点
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero2);
        
        //展示
        singleLinkedList.list();

    }
}

//定义单链表 用于管理英雄
class SingleLinkedList{
    //初始化头节点，不存放具体的数据
    private HeroNode head = new HeroNode(0,"","");

    //添加节点到单项链表
    public void add(HeroNode heroNode){
        //辅助遍历
        HeroNode temp = head;
        //遍历找到最后一个节点
        while (temp.next != null) {
            temp = temp.next;
        }
        //退出循环后temp指向了链表的最后
        //将最后这个节点的next指向新节点
        temp.next = heroNode;
    }

    public void addByOrder(HeroNode heroNode){
        HeroNode temp = head;
        boolean flag = false;
        while (temp.next != null && temp.next.no <= heroNode.no){
            if (temp.next.no == heroNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            System.out.println("准备插入的英雄编号已经存在了，不能再次添加");
        }else {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //遍历展示链表
    public void list(){
        if (head.next == null){
            System.out.println("链表为空");
            return ;
        }
        HeroNode temp = head.next;
        while (temp != null) {
            System.out.println(temp);
            temp = temp.next;
        }
    }

}

//定义节点 每个HeroNode对象就是一个节点
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 + '\'' +
                '}';
    }
}

在这里插入图片描述

修改节点信息

思路

  1. 通过变量找到要修改的节点
  2. temp.name = newHeroNode.name

代码实现

package com.zls.demo03;

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        //先创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");

        SingleLinkedList singleLinkedList = new SingleLinkedList();
        //添加节点
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero2);

        //展示
        singleLinkedList.list();


        //修改节点
        HeroNode newHeroNode = new HeroNode(2,"小卢","玉麒麟~~");
        singleLinkedList.update(newHeroNode);

        //展示
        System.out.println("修改链表后：");
        singleLinkedList.list();
    }
}

//定义单链表 用于管理英雄
class SingleLinkedList{
    //初始化头节点，不存放具体的数据
    private HeroNode head = new HeroNode(0,"","");

    //添加节点到单项链表
    public void add(HeroNode heroNode){
        //辅助遍历
        HeroNode temp = head;
        //遍历找到最后一个节点
        while (temp.next != null) {
            temp = temp.next;
        }
        //退出循环后temp指向了链表的最后
        //将最后这个节点的next指向新节点
        temp.next = heroNode;
    }

    public void addByOrder(HeroNode heroNode){
        HeroNode temp = head;
        boolean flag = false;
        while (temp.next != null && temp.next.no <= heroNode.no){
            if (temp.next.no == heroNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            System.out.println("准备插入的英雄编号已经存在了，不能再次添加");
        }else {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //修改节点的信息，根据no编号修改
    public void update(HeroNode newHeroNode){
        if (head.next == null){
            System.out.println("链表为空");
            return ;
        }
        HeroNode temp = head.next;
        boolean flag = false;
        while (temp != null){
            if(temp.no == newHeroNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        }else{
            System.out.println("该节点不存在");
        }
    }


    //遍历展示链表
    public void list(){
        if (head.next == null){
            System.out.println("链表为空");
            return ;
        }
        HeroNode temp = head.next;
        while (temp != null) {
            System.out.println(temp);
            temp = temp.next;
        }
    }

}

//定义节点 每个HeroNode对象就是一个节点
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 + '\'' +
                '}';
    }
}

在这里插入图片描述

删除节点

思路

  1. 先找到需要删除的节点的前一个节点temp
  2. temp.next = temp.next.next
  3. 被删除的节点不会有其他引用指向，会被垃圾回收机制回收。

代码实现

package com.zls.demo03;

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        //先创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");

        SingleLinkedList singleLinkedList = new SingleLinkedList();
        //添加节点
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero2);

        //展示
        singleLinkedList.list();

        //删除节点
        singleLinkedList.del(1);
        singleLinkedList.del(3);

        System.out.println("删除后的节点展示");
        singleLinkedList.list();
    }
}

//定义单链表 用于管理英雄
class SingleLinkedList{
    //初始化头节点，不存放具体的数据
    private HeroNode head = new HeroNode(0,"","");

    //添加节点到单项链表
    public void add(HeroNode heroNode){
        //辅助遍历
        HeroNode temp = head;
        //遍历找到最后一个节点
        while (temp.next != null) {
            temp = temp.next;
        }
        //退出循环后temp指向了链表的最后
        //将最后这个节点的next指向新节点
        temp.next = heroNode;
    }

    public void addByOrder(HeroNode heroNode){
        HeroNode temp = head;
        boolean flag = false;
        while (temp.next != null && temp.next.no <= heroNode.no){
            if (temp.next.no == heroNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            System.out.println("准备插入的英雄编号已经存在了，不能再次添加");
        }else {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //修改节点的信息，根据no编号修改
    public void update(HeroNode newHeroNode){
        if (head.next == null){
            System.out.println("链表为空");
            return ;
        }
        HeroNode temp = head.next;
        boolean flag = false;
        while (temp != null){
            if(temp.no == newHeroNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        }else{
            System.out.println("该节点不存在");
        }
    }

    public void del(int no){
        HeroNode temp = head;
        boolean flag = false;
        while(temp.next != null){
            if (temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.next = temp.next.next;
        }else {
            System.out.println("要删除的节点不存在");
        }
    }


    //遍历展示链表
    public void list(){
        if (head.next == null){
            System.out.println("链表为空");
            return ;
        }
        HeroNode temp = head.next;
        while (temp != null) {
            System.out.println(temp);
            temp = temp.next;
        }
    }

}

//定义节点 每个HeroNode对象就是一个节点
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 + '\'' +
                '}';
    }
}

在这里插入图片描述

Java实例

使用场景

需要通过循环迭代来访问列表中的某些元素。
需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。

  • LinkedList 继承了 AbstractSequentialList 类。
  • LinkedList 实现了 Queue 接口，可作为队列使用。
  • LinkedList 实现了 List 接口，可进行列表的相关操作。
  • LinkedList 实现了 Deque 接口，可作为队列使用。
  • LinkedList 实现了 Cloneable 接口，可实现克隆。
  • LinkedList 实现了 java.io.Serializable 接口，即可支持序列化，能通过序列化去传输。

使用

import java.util.LinkedList;

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        // 使用 add() 添加元素
        sites.add("Taobao");
        System.out.println(sites);

        // 使用 addFirst() 在头部添加元素
        sites.addFirst("Wiki");
        System.out.println(sites);

        // 使用 addLast() 在尾部添加元素
        sites.addLast("CSDN");
        System.out.println(sites);

        // 使用 removeFirst() 移除头部元素
        sites.removeFirst();
        System.out.println(sites);

        // 使用 removeLast() 移除尾部元素
        sites.removeLast();
        System.out.println(sites);

        // 使用 getFirst() 获取头部元素
        System.out.println(sites.getFirst());
        
        // 使用 getLast() 获取尾部元素
        System.out.println(sites.getLast());
    }
}

在这里插入图片描述

我还能码嘛。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构 -- 链表
sdjn_lyn的博客
02-26 276
单链表(ForwardList) 链表是链式存储结构的线性表的实现，由于内存地址不连续，所以链表不仅要有数据域，还要存储后继结点指针，如果一个结点只有一个指向后继结点的指针域，那么该线性表称为单链表 头指针与头结点 头指针中存储的是第一个结点的内存地址，通过头指针找到第一个结点，之后通过第一个结点的指针域可以找到第二个结点，以此类推，可以找到链表的最后一个结点，最后一个结点的指针域为空（nullp...
数据结构--链表
m0_55137286的博客
08-15 102
一.常见的数据结构 栈（Stack）：栈是一种特殊的线性表，它只能在一个表的一个固定端进行数据结点的插入和删除操作。 队列（Queue）：队列和栈类似，也是一种特殊的线性表。和栈不同的是，队列只允许在表的一端进行插入操作，而在另一端进行删除操作。 数组（Array）：数组是一种聚合数据类型，它是将具有相同类型的若干变量有序地组织在一起的集合。 链表（Linked List）：链表是一种数据元素按照链式存储结构进行存储的数据结构，这种存储结构具有在物理上存在非连续的特点。 树（Tree）：树是典型的
java数据结构-链表详解
m0_63526467的博客
05-04 4058
文章目录1.数据结构-链表详解1.1单链表1.1.1单链表节点的尾部添加1.1.2单链表节点的自动排序添加1.1.3单链表节点的修改1.1.4单链表节点的删除1.2单链表面试题1.2.1单链表的有效节点个数1.2.2单链表倒数第k个结点1.2.3单链表反转1.2.4单链表逆序打印1.3双向链表1.3.1双向链表介绍1.3.2双向链表增删改查1.4单向环形链表1.4.1约瑟夫（Josephu）环问题 1.数据结构-链表详解 链表可分为三类： 单链表 双向链表 循环列表 下面具体分析三个链表的应用。 1.1
数据结构 -- 链表详解
m0_73243771的博客
04-27 2022
链表详解，重点讲解两种常用的链表，看到就是赚到！！！
数据结构-链表篇
热门推荐
qq_16268979的博客
01-10 1万+
数据结构-链表篇
数据结构-链表.pdf
04-15
数据结构-链表 单向链表，双向链表、循环链表等
C语言数据结构-链表版学生管理系统
10-02
《C语言数据结构-链表版学生管理系统》 在计算机科学中，数据结构是组织、存储和处理数据的重要工具，而链表作为一种基础且灵活的数据结构，被广泛应用于各种复杂算法和系统设计中。本项目《C语言数据结构-链表版...
数据结构-链表相关功能和算法
06-11
链表是一种基础且重要的数据结构，它在计算机科学和编程中扮演着不可或缺的角色。相比于数组，链表在处理动态数据集合时提供了更大的灵活性。在这个"数据结构-链表相关功能和算法"的主题中，我们将深入探讨链表的...
数据结构-链表的C语言使用
03-25
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。在C语言中，链表不像是数组那样在内存中连续存储元素，而是通过一系列分散的内存块（称为节点）来表示数据。每个...
数据结构day3
qq_55245263的博客
07-18 258
顺序表实现学生管理系统
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1031
可以参考以下视频。
数组算法--基本查找
2303_78660417的博客
07-20 292
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 222
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
数据结构第32节 无锁编程
hummhumm的专栏
07-17 851
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
C语言排序算法
最新发布
m0_49476241的博客
07-21 717
本篇文章带大家来学习C语言的基本算法。本篇文章主要为大家讲解了C语言中的排序算法，在笔试面试当中可能会经常考察到这些排序算法。
数据结构——栈
weixin_45942515的博客
07-19 247
1、栈的英文为stack2、栈是先入后出（FILO-First In Last Out）的有序列表。3、栈stack是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶 (Top)，另一端固定的一端，称为栈底(Bottom)。4、根据栈的定义可知，最先放入栈中的元素在栈底，最后放入栈中的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
数据结构之细说链表
m0_73634434的博客
07-17 1062
这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了。头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。下面我们给出链表的构成，看看链表是如何解决这些问题的。
24暑假算法刷题 | Day16 | LeetCode 513. 找树左下角的值，112. 路径总合，106. 从中序和后序遍历序列构造二叉树
weixin_54468359的博客
07-18 1084
24暑假刷题day15打卡 二叉树进阶
数据结构 day2
没有百宝袋的哆啦A梦的博客
07-17 1166
由相同数据类型或不同数据类型构成的集合，但是，该集合中的成员共享同一块内存空间union 结构体名称成员类型1 成员变量1;成员类型2 成员变量2；。。。成员类型n 成员变量n;当程序员写程序时，可能会因为数据类型的问题，在定义变量时，导致该程序比较晦涩难懂，例如：unsigned long int ,struct Stu为了提高代码的简洁性，以及为了更加方便理解使得代码更加优雅，我们可以将这些类型重新起一个简洁好记的名字。引入了关键字 typedef。
数据结构-链表按序号查找算法解析
本资源主要涵盖了数据结构中的查找运算，特别是针对链表的按序号查找操作。在数据结构中，查找运算是一项基础且重要的操作，它涉及到如何有效地在数据集合中定位特定的信息。在讲解查找运算之前，我们首先理解数据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值