Java 数据结构与算法笔记 003 链表实现列表

已于 2022-04-02 21:06:01 修改
阅读量559 收藏
点赞数
分类专栏： Java数据结构与算法 文章标签： java 开发语言 后端
于 2022-03-27 22:14:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51614397/article/details/123783110
版权
简介：笔记 链表实现列表

用链表来实现列表

链表

链表是有序的列表，其特点如下：

  • 链表是以节点的方式储存的

  • 链表的每一个节点内都包含两大部分的内容，一个内容存储数据，一个内容存储下一个节点的位置

  • 链表的节点在内存空间中不一定是连续存储的（但在逻辑结构上是连续存储的）

  • 链表的分类

    • 带头节点的链表

      头结点

      • 头结点不存放数据
      • 头结点的作用是表示单链表的头（相当于火车头的作用）

    • 不带头节点的链表

单链表

一个示例：使用带有头节点的单向链表实现水浒人物排行榜的管理

要实现上面的功能，就是我们要实现对英雄人物的增删改查等操作，对于添加英雄人物这个操作，我们有两种方式可以完成

  • 将英雄直接添加到链表的尾部
  • 根据排名将英雄插入指定的位置

第一种方式：直接将英雄添加到链表的尾部

package com.atguigu.linkedlist;

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();
    }
}

// 定义SingleLinkedList
class SingleLinkedList {
    private HeroNode head = new HeroNode(0, "", "");

    // 往链表中添加元素（添加到末尾的位置）
    public void add(HeroNode heroNode) {
        // 在将节点添加到单向链表的末尾的时候，应当找到最后的那个节点，所以，在这里，我们需要一个辅助的节点来帮助我们找到最后的那个节点
        // 最后的那个节点的 next 默认为 null，利用这个特点作为判断就可以找到最后的节点了
        HeroNode temp = head;
        // 老师这里用死循环加 if 判断的，结果是一样的
        while(temp.next != null){
            temp = temp.next;
        }
        // 当跳出循环的时候 temp 指向的就是最后的节点，把要添加的节点接上就可以了
        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 + "]";
    }
}

这种方法有个缺点是：如果我们没有按序号来进行添加的话，那么链表中的元素序号就不是从小到大（或者从大到小），所以下面的例子是另外一种方式的，按照序号大小进行排序后再加入到链表中

第二种方式：根据排名插入英雄（如果英雄排名已经有的情况下，插入失败）

package com.atguigu.linkedlist;

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.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        singleLinkedList.list();

        HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~~");
        singleLinkedList.update(newHeroNode);

        singleLinkedList.list();
    }
}

// 定义SingleLinkedList
class SingleLinkedList {
    private HeroNode head = new HeroNode(0, "", "");

    // 往链表中添加元素（添加到末尾的位置）
    public void add(HeroNode heroNode) {
        // 在将节点添加到单向链表的末尾的时候，应当找到最后的那个节点，所以，在这里，我们需要一个辅助的节点来帮助我们找到最后的那个节点
        // 最后的那个节点的 next 默认为 null，利用这个特点作为判断就可以找到最后的节点了
        HeroNode temp = head;
        // 老师这里用死循环加 if 判断的，结果是一样的
        while(temp.next != null){
            temp = temp.next;
        }
        // 当跳出循环的时候 temp 指向的就是最后的节点，把要添加的节点接上就可以了
        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;
        }
    }

    // 根据序号将节点添加到链表中
    public void addByOrder(HeroNode heroNode){
        HeroNode temp = head;
        boolean flag = false;
        while(true){
            if(temp.next == null){
                break;
            }
            if(temp.next.no > heroNode.no){
                break;
            } else if(temp.next.no == heroNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            System.out.println("准备插入的英雄的编号" + heroNode.no + "已经存在，无法插入");
        } else {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    public void update(HeroNode newHeroNode){
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        HeroNode temp = head.next;
        boolean flag = false;
        while(true){
            if(temp == null){
                break;
            }
            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("没有找到编号为" + newHeroNode.no + "的节点，无法修改");
        }
    }
}

// 定义 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 + "]";
    }
}

这段代码在实现根据编号插入英雄（ addByOrder ）的基础上，还在 SingleLinkedList 类的内部添加了一个 update 方法，这个方法实现了更改节点信息的方

addByOrder 方法的思路

  1. 添加两个变量，一个是临时节点 temp （刚开始时指向头节点），另外一个是判断标志 flag（ boolean 类型，默认为 false ，表明要插入的节点在链表中还没有存在）

    HeroNode temp = head;
boolean flag = false;

  2. 在 while 死循环里面对节点进行循环判断，找到要插入节点的位置

    1. 如果 temp.next 指向的为空，则表明已经到达链表的末尾了，在末尾之前并没有找到插入的地方，所以待会要将节点插入到这里

      if(temp.next == null){
    break;
}

    2. 如果 temp.next.no 比添加的节点的编号（no）要大，则表明，插入的节点已经找到，在 temp 节点与 temp 的下一个节点之间插入，此时，break 打断循环

      if(temp.next.no > heroNode.no){
    break;
}

    3. 如果 temp.next.no 和要添加的节点的编号一样大，那么表明要添加的节点已经存在，无法添加，所以修改 flag 的值，并打断循环

      else if(temp.next.no == heroNode.no) {
    flag = true;
    break;
}

    4. 在循环里面要对 temp 进行迭代

      temp = temp.next;

  3. 经过循环之后，要么我们找到了添加节点的位置，要么我们要添加的节点已经存在，无法添加，所以，对 flag 变量进行判断之后执行相应即可了

    if(flag){
    System.out.println("准备插入的英雄的编号" + heroNode.no + "已经存在，无法插入");
} else {
    heroNode.next = temp.next;
    temp.next = heroNode;
}
update 方法的思路

  1. 先判断是否有节点（ head.next 的值是否为 null ），如果有节点的话将 temp （一个临时节点）指向第一个节点（就是 head.next指向的节点），如果没有节点的话，直接 return 跳出方法

    if(head.next == null){
    System.out.println("链表为空");
    return;
}

  2. 在 while 循环（一个死循环）里面通过遍历的方式将添加节点的位置找出来（节点 temp 所指向的节点就是我们每次在循环里面要进行判断操作的节点）

    1. 在 while 循环的外面先设置两个变量，分别是临时节点 temp 和 一个判断标志 flag （ boolean 类型的，默认值为 false ，表明没有找到要修改信息的节点）

      HeroNode temp = head.next;
boolean flag = false;

    2. 判断节点是否为空（节点为空，此时 temp 指向的是链表末尾节点的后一个位置），如果为空，则表明没有在循环的过程之中找到我们要修改的节点，此时，跳出循环

      if(temp == null){
    break;
}

    3. 判断 temp 指向的节点的 no 值是否等于新添加节点的 no 值，如果是，则表明节点已经找到，将标志改为 true 并退出循环

      if(temp.no == newHeroNode.no){
    flag = true;
    break;
}

    4. 最后，在循环的末尾要对 temp 的值进行迭代

      temp = temp.next;

  3. 经过循环之后，根据 flag 的值判断我们有没有找到修改信息的节点

    1. 如果找到了，修改节点的信息

      if(flag){
    temp.name = newHeroNode.name;
    temp.nickname = newHeroNode.nickname;
}

    2. 如果没有找到，打印相关的信息，告知用户我们没有找到相关节点，无法进行修改的操作

      else{
    System.out.println("没有找到编号为" + newHeroNode.no + "的节点，无法修改");
}

丰富链表的功能：删除节点，实现的方式

  1. 找到要删除节点的前一个节点
  2. temp.next = temp.next.next ，被删除的节点没有人指向它，会被 gc 垃圾回收
public void del(int no){
    HeroNode temp = head;
    boolean flag = false;
    while(true){
        if(temp.next == null){
            break;
        }
        if(temp.next.no == no){
            flag = true;
            break;
        }
        temp = temp.next;
    }
    if(flag){
        temp.next = temp.next.next;
    } else {
        System.out.println("链表中没有要删除的节点");
    }
}

参考资料：https://www.bilibili.com/video/BV1E4411H73v?p=21&spm_id_from=333.880.my_history.page.click

薯-叶
关注
专栏目录
链表的实现（LinkedList）
xiaocl123的博客
05-14 130
List 接口 // 将ArrayList 和 LinkedList 的共性方法定义一个接口，保证体系的完整性 public interface List<E>{ // 三个基本方法 int size(); boolean isEmpty(); // 增 void add(E element); void add(int index,E element); // 删 E remove(int index); // 改
【久远讲算法】链表——实现无序列表
nruuu的博客
10-30 604
你好，我是久远，上周开始我们算是正式入门了数据结构，进行了数组的讲解。 我们现在来总结回顾一下数组的知识。 数组是什么？ 是由相同类型的元素的集合所组成的数据结构，分配一块连续的内存来存储。利用元素的索引（index）可以计算出该元素对应的存储地址。 数组的储存类型 顺序存储：数组在内存中的顺序存储，具体是什么样子呢？ 内存是由一个个连续的内存单元组成的，每一个内存单元都有自己的地址。在这些内存单元中，有些被他数据占用了，有些是空闲的。 数组中的每一个元素，都存储在小小的内存单元中，并且元素之间紧密
（java）链表的转换
飞行的码农
09-28 840
给定一个链表，比如L1--->L2---->L3---->................----->Ln，把链表调整为L1---->Ln----->L2----->Ln-1------>L3------>Ln-3........... 要求: 1、间复杂度O（1）； 思路：将后一半元素逆转之后，就可以按照后一半逆转之后的顺序插入到前一半链表中。 代码如下： impo
【JAVA 单链表】反转单链表
m0_45097186的博客
11-16 162
节点类： class ListNode { public int data; //data可以是任何类型 public ListNode next; public ListNode(int data) { this.data = data; this.next = null; } } class TestDemon1 { ...
java 实现链表向集合转化使用toArray()
至简
11-15 2338
<br />import java.util.ArrayList;<br /> import java.util.HashSet;<br /> import java.util.Iterator;<br /> import java.util.List;<br /> import java.util.Set;<br /><br /> public class ArrayCollection {<br />     /*<br />      * 实现链表向集合转化使用toArray()<br
【尚硅谷】Java数据结构与算法笔记03 - 链表
热门推荐
知不足而奋进，望远山而前行
12-07 2万+
链表是有序的列表，它在内存中的存储如下：单链表(带头结点) 逻辑结构示意图如下：使用带 head 头的单向链表实现 - 水浒英雄排行榜管理完成对英雄人物的增删改查操作 输出： 2.3 面试题（新浪、百度、腾讯） 求单链表中有效节点的个数 查找单链表中的倒数第k个结点 单链表的反转 从尾到头打印单链表 合并两个有序链表 三、双向链表 3.1 思路分析 使用带 head 头的双向链表实现 - 水汻英雄排行榜管理单向链表的缺点分析:分析 双向链表的遍历, 添加, 修改, 删除的操作思路 ===>===>===
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
Java数据结构和算法笔记.doc
07-11
【Java数据结构和算法笔记】 在Java编程中，数据结构和算法是核心概念，它们直接影响程序的效率和可维护性。本笔记主要基于《Java数据结构和算法》(第二版)一书，概述了各种常见数据结构的特性及经典算法。 1. **...
Java数据结构和算法详细笔记
07-09
Java作为面向对象的编程语言，支持多种数据结构和算法的实现。 线性结构是数据结构的一种，它的特点是数据元素之间存在一对一的线性关系。在Java中，线性结构主要包括以下几种类型： 1. **数组**：是最基本的线性...
【java】61. 旋转链表---记录链表前一个结点，并设置该节点的next属性为null,踩坑的一天！！！
惠菁
03-29 141
给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。 示例 1： 输入：head = [1,2,3,4,5], k = 2 输出：[4,5,1,2,3] 示例 2： 输入：head = [0,1,2], k = 4 输出：[2,0,1] 提示： 链表中节点的数目在范围 [0, 500] 内 -100 <= Node.val <= 100 0 <= k <= 2 * 109 代码： public ListNode rotateRight(ListNode h
java head head.next_Java: 链表head取出用后，置next=null为何可以加速gc？
weixin_39612726的博客
02-13 301
如有openjdk源码，则可用如下命令查找添加// help GC的时间和rev号hg annotate -ufd src\java.base\share\classes\java\util\LinkedList.javarev 66ef929d58f2 2009-11-06可以参考《深入理解Java虚拟机》，楼主应该是有这本书的。试想一个问题，gc会检测GC Roots。切记，是Roots！GC...
【Java---数据结构】链表（单向不带头非循环链表）
.很冷的博客
03-13 776
顺序表和链表是数据结构的基础内容。 有些人比较好奇，C语言的数据结构和Java的数据结构有什么区别？答案就是：没区别，数据结构是一门单独的学科，和语言没有关系。只是用不同的语言实现一样的逻辑。 文章使用Java语言介绍顺序表与链表。 一、线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表
带头单链表Java实现
weixin_62756510的博客
04-27 1133
目录带头单链表一、概念二、要点总结三、代码实现1. 类结构2. 带头单链表的遍历3. 插入结点3. 1. 头插法3.2. 指定索引处插入结点3.3 尾插法4. 删除结点4.1. 删除指定索引处的结点4.2 删除所有值为val的结点 带头单链表 一、概念 带头单链表中默认带有一个虚拟头结点dummyHead，不存储有效元素。 二、要点总结 链表中仅创建了虚拟头结点的Node对象 private Node dummyHead = new Node(); 虚拟头结点的属性值val默认为0（不存储有效元素），
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1268
项目功能：商品分类,商品信息,用户。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 1047
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
java_方法递归调用
HHppGo的博客
10-27 512
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
ssm智慧社区电子商务系统+vue
weixin_44832324的博客
10-28 1235
系统能否进行正常工作，功能模块能否实现，程序代码是否有错误，这些都需要通过系统测试来进行判断，测试是程序开发中必不可少的步骤，就算系统一步不差的被开发出来了，但进行测试时总能发现一个之前从没遇到过的问题[26]。在系统开发的整个过程当中都需要不断进行系统测试，根据经验发现，前期的一个小问题，将会酿成后期的一个大问题，所以越早发现，越早解决，才能保证后续的编码、测试和设计能够顺利进行。目前，系统测试所使用的方法主要是黑盒测试，系统测试的目的包括：根据客户的需求来设计用户界面；
Java复习24（PTA)
最新发布
2301_79272475的博客
10-30 396
Java复习24（PTA)：多种排序的book类*
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值