数据结构与算法学习笔记(java版)——第三章 链表

最新推荐文章于 2026-06-20 18:32:07 发布
原创 最新推荐文章于 2026-06-20 18:32:07 发布 · 977 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#数据结构 #java #开发语言 #算法
本文详细介绍了链表的基础概念，包括单链表的创建、节点操作（添加、排序）、双向链表的结构与操作（插入、删除、查询），并展示了实际代码示例。重点讲解了按学号自动排序和节点修改功能。

第三章 链表

3.1 链表的介绍

  • 链表是有序的列表，但是它在内存中的储存如下：
    在这里插入图片描述
  • 总结
    1. 链表是以结点的方式来存储的
    2. 每个结点包含data域：存储数据；next域：指向下一个结点
    3. 如图：发现链表的各个节点不一定是连续存储的
    4. 链表分带头结点的链表和不带头结点的链表，根据实际需求来确定

3.2 单链表介绍

3.2.1 单链表的创建示意图(添加)，显示对象链表的分析

在这里插入图片描述

3.2.2 单链表操作

  • 创建（添加）：
    1. 先创建一个head头结点，作用就是表示单链表的头
    2. 后面我们每添加一个节点，就直接加入到链表的最后
  • 遍历
    1. 通过一个数组辅助变量遍历，帮助遍历整个链表
  • 按学号大小进行添加，即添加时自动排序
    1. 首先找到新添加的节点的位置，时通过辅助变量（指针）
    2. 新的节点.next=temp.next
    3. 将temp.next=新的节点
    4. 演示图：
      在这里插入图片描述
package com.wkj;

import sun.security.provider.certpath.PKIXTimestampParameters;

/**
 * @author xxiao
 * @date 2022/2/7 - 16:41
 */
public class SingleLinkedListDemo {
    public static void main(String[] args) {
        //测试
        //先创建节点
        HeroNode heroNode1 = new HeroNode(new Student(1,"张三",18));
        HeroNode heroNode2 = new HeroNode(new Student(2,"李四",22));
        HeroNode heroNode3 = new HeroNode(new Student(4,"王五",21));
        HeroNode heroNode4 = new HeroNode(new Student(5,"李六",23));

        //创建一个链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        //加入
/*        singleLinkedList.add(heroNode1);
        singleLinkedList.add(heroNode4);
        singleLinkedList.add(heroNode3);
        singleLinkedList.add(heroNode2);
        singleLinkedList.list();*/

        //加入按照编号的顺序
        singleLinkedList.addById(heroNode1);
        singleLinkedList.addById(heroNode4);
        singleLinkedList.addById(heroNode3);
        singleLinkedList.addById(heroNode2);
        singleLinkedList.list();


        //显示按添加排名显示出来

    }
}

    //定义SingleLinkedList
class SingleLinkedList{
    //先初始化一个头结点，头结点不要动，不存放具体的数据
    private HeroNode head = new HeroNode(null);

    //添加节点到单向链表
    //思路：当不考虑编号顺序是
    //1、找到当前链表的最后节点
    //2、将最后这个节点的next指向新节点

    public void add(HeroNode heroNode){
        //因为head节点不能动，因此我们需要一个辅助遍历temp
        HeroNode temp = head;
        //遍历链表，找到最后
        while (true){
            //找到链表的最后
            if (temp.next==null){
                break;
            }
            //如果没有找到最后，将temp后移
            temp = temp.next;
        }
        //当退出while循环是，temp就指向了链表的最后
        //将最后这节点的next指向新的节点
        temp.next = heroNode;
    }

    public void addById(HeroNode heroNode){
        //因为头结点不能动，因此我们仍然通过一个辅助指针（变量）来帮助找到添加的位置
        //因为单链表，我们找到temp的位置时位于添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        while (true){
            if (temp.next==null){
                break;
            }
            if (temp.next.stu.id>heroNode.stu.id){
                break;
            }
            temp = temp.next;
        }
        heroNode.next = temp.next;
        temp.next = heroNode;
    }

    //显示链表（遍历）
    public void list(){
        if (head.next==null){
            System.out.println("链表为空！");
            return;
        }

        //因为头结点不能动，因此我们需要一个辅助变量来遍历
        HeroNode temp = head.next;
        while (true){
            if (temp == null){
                break;
            }
            System.out.println(temp);
            //将next后移，不后移会是死循环
            temp = temp.next;
        }
    }
}

class Student{
    public int id;
    public String name;
    public int age;

    public Student() {
    }

    @Override
    public String toString() {
        return "Student{" +
                "no=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public int getNo() {
        return id;
    }

    public void setNo(int no) {
        this.id = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student(int no, String name, int age) {
        this.id = no;
        this.name = name;
        this.age = age;
    }
}

//定义HeroNode，每个HeroNode对象就是一个节点
class HeroNode{
    public Student stu;
    public HeroNode next;

    public HeroNode(Student stu) {
        this.stu = stu;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "stu=" + stu +
                '}';
    }
}

  • 普通添加效果图：
    在这里插入图片描述

  • 加入自动排序效果图：
    在这里插入图片描述

  • 修改：根据编号修改

    public void updata(HeroNode heroNode){
        if (head.next==null){
            System.out.println("链表为空！");
            return;
        }
        HeroNode temp = head.next;
        boolean falg = false;
        while (true){
            if(temp==null){
                break;
            }
            if (temp.stu.id==heroNode.stu.id){
                falg = true;
                break;
            }
            temp = temp.next;
        }

        if (falg){
            temp.stu.name = heroNode.stu.name;
            temp.stu.age = heroNode.stu.age;
        }else{//没有找到
            System.out.println("没有找到编号为"+heroNode.stu.id+"的节点");
        }
    }

显示效果：
在这里插入图片描述

  • 节点的删除
    1. 辅助变量找到节点的上一个节点
    2. temp.next = temp.next.next
    3. 被删除的节点，不会有其它引用指向，将会被垃圾回收机制回收

代码：

   public void delete(int id){
        HeroNode temp = head;
        boolean flag = false;//标识是否找到删除节点
        while (true){
            if (temp.next == null){
                break;
            }
            if (temp.next.stu.id == id){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.next = temp.next.next;
        }else {
            System.out.println("要删除的"+id+"不存在");
        }
    }

效果图：
在这里插入图片描述

3.3 双向链表

3.3.1 双向链表介绍

  • 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表
  • 结构图
  • 双向链表即每个节点有前置域和后置域。前置域指向上一个节点。后置节点指向下一个节点。

3.3.2 双向链表的添加

  1. 新节点的前置next域指向temp
  2. temp.next=新的节点
  • 示意图
    在这里插入图片描述
  • 代码
public void add(DuLink duLink){
        //因为head节点不能动，因此我们需要一个辅助遍历temp
        DuLink temp = head;
        //遍历链表，找到最后
        while (true){
            //找到链表的最后
            if (temp.next==null){
                break;
            }
            //如果没有找到最后，将temp后移
            temp = temp.next;
        }
        //当退出while循环是，temp就指向了链表的最后
        //将最后这节点的next指向新的节点
        duLink.pro = temp;
        temp.next = duLink;
    }

3.3.3 双向链表的插入

  • 双向链表的插入共四步，且有些顺序不能颠倒：
  • 第一步：先把temp的下一个指向的节点先引用到新节点中。
  • 第二步：将temp的next引用于新节点
    在这里插入图片描述
    public void headAdd(DuLink duLink){
        //如果只有头结点
        if(head.next==null){
            head.next=duLink;
            duLink.pro=head;
        }else{
            head.next.pro = duLink;
            duLink.next = head.next;
            head.next=duLink;
            duLink.pro=head;
        }
    }
    /**双向链表添加-尾插法*/
    public void tailAdd(DuLink duLink){
        DuLink temp = head;
        while(true){
            if(temp.next==null){
                break;
            }
            temp = temp.next;
        }
        temp.next=duLink;
        duLink.pro=temp;
    }

3.3.4 双向链表的删除

  • temp.next.pro = temp.pro;
  • temp.pro.next = temp.next;
  • 代码
  /**双向链表的删除
     * 删除某一学号的节点*/
    public void delete(int no){
        if(head.next==null){
            System.out.println("列表为空");
            return;
        }
        boolean flag=false;
        DuLink temp = head.next;
        while(true){
            if(temp.stu.getNo()==no){
                flag=true;
                break;
            }
            if(temp.next==null){
                flag=false;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.next.pro = temp.pro;
            temp.pro.next = temp.next;
        }else {
            System.out.println("找不到学号为："+no+"的节点");
        }
    }

3.3.5 双向链表的查询

/**双向链表的遍历*/
    public void duLinkList(){
        if(head.next==null){
            System.out.println("列表为空");
            return;
        }
        DuLink temp = head;
        while(true){
            if(temp.next==null) {
                break;
            }
            temp = temp.next;
            System.out.println(temp.toString());
        }
    }

3.3.6 双向链表的插入

/**双向链表的插入
     * 插入到某个学号的后面*/
    public void insert(DuLink duLink,int no){
        if(head.next==null){
            System.out.println("列表为空");
            return;
        }
        boolean flag=false;
        DuLink temp = head.next;
        while(true){
            if(temp.stu.getNo()==no){
                flag=true;
                break;
            }
            if(temp.next==null) {
                break;
            }
            temp = temp.next;
        }
        if(flag){
            temp.next.pro = duLink;
            duLink.next = temp.next;
            temp.next=duLink;
            duLink.pro=temp;
        }else {
            System.out.println("找不到学号为："+no+"的节点");
        }
    }

3.3.7 双向链表的修改

 /**双向链表的修改
     * 修改学好的全部数据*/
    public void updata(Student stu,int no){
        if(head.next==null){
            System.out.println("列表为空");
            return;
        }
        boolean flag=false;
        DuLink temp = head.next;
        while(true){
            if(temp.stu.getNo()==no){
                flag=true;
                break;
            }
            if(temp.next==null){
                flag=false;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.stu=stu;
        }else {
            System.out.println("找不到学号为："+stu.getNo()+"的节点");
        }
    }
五更钟动
关注
带头结点和不带头结点的循环链表
11-24
这学期学数据结构，写了带头结点和不带头结点的循环链表，供其他在校学生参考学习，体会在链表中带头结点和不带头结点的差别
单链表的两种简单实现（有头节点和无头节点）
12-09
重学数据结构第一步：简单实现下链表，功能不是很完善，重在学习思想。
链表头结点和不带头结点的区别
Keep Moving~
11-17 1万+
一、概念辨析 线性表的插入删除需要移动大量的元素，因此引入链表（本文讨论单链表）的概念，链表元素之间通过“链”来链接，因此插入和删除时不需要大量的移动元素，而只需要改变“链”的关系即可。 头指针：通常使用“头指针”来标识一个链表，如单链表L，头指针为NULL的时表示一个空链表。链表非空时，头指针指向的是第一个结点的存储位置。 头结点：在单链表的第一个结点之前附加一个结点，称为头结点。头结点的Dat...
关于链表-不带头节点和带头节点的区别
2403_82706967的博客
11-16 1403
带头指针和带头节点链表的区别、分割链表
链表带头和不带头的区别及其应用
小李很执着的博客
04-07 1359
不带头链表是指链表中没有额外的头结点，即链表的第一个结点即为链表的起始点。不带头链表的结构上的区别是，链表的第一个结点即为链表起始点，没有额外的头结点。不带头链表的形式上的区别是，在对链表进行操作时，通常从第一个结点开始遍历。int data;// 创建节点函数// 插入节点函数} else {= NULL) {// 打印链表函数= NULL) {return 0;带头链表：带头链表是指在链表的头部添加一个额外的头结点，
【链表】带头节点和不带头节点单链表的区别
风铃的博客
12-11 9260
目录 ????当链表的结点只包含一个指针域时，叫做单链表 ????不论带不带头节点，所有的链表都要有个头指针！ ????带头结点的链表的头指针指向的是头结点，头结点的指针域指向首元结点 ????不带头结点的头指针直接指向首元结点 ????初始化 ????2.带头节点的初始化 ????不带头节点的初始化 ????判空条件 ????带头节点 ????不带头节点 ????操作上有区别 ????带头节点 ????不带头节点 ????当链表的结点只包含一个指针域时，叫做单链表 ?
Java数据结构与算法之学习路线
Andy_lau
09-28 1万+
目录： 1.前言 2.数据结构与算法学习大纲(粗糙) 3.线性结构分类 4.各个线性类型数据结构的特点以及使用场景 5.数组与队列的区别 1.前言： 昨天去面试了一家我觉得薪资和公司文化都不错的公司，也不知道是天真还是没得自知之明，一个普通本科去跟人家985，211高校的 竞争，哎，就想着试试，喜欢就上嘛，然后就去了。去做了两道面试题，全是数据结构和算法的题，由于我的java和
数据结构与算法基础（java版）
weixin_41965053的博客
11-02 2437
前言 数据结构与算法是一门相对比较枯燥，但也是编程人员必学的课程。通过学习数据结构与算法，可以提高我们在编程中的思维逻辑；本人也是小白一枚，学习了一段时间后，在这边总结下；尽量以比较白话的方式，来进行更好的理解。 数据结构概述 数据结构可以简单的理解为数据与数据之间所存在的一些关系，数据的结构分为数据的存储结构和数据的逻辑结构。 存储结构 ...
Java数据结构与算法学习指南(第二版)
weixin_42596214的博客
08-16 939
数据结构是计算机存储、组织数据的方式，它旨在实现高效的数据访问和修改。在本章中，我们将了解一些最基本的数据结构：数组、链表、栈、队列、树和图。这些结构构成了更复杂数据组织的基础，并在算法设计中起着关键作用。二叉树是一种非线性的数据结构，其中每个节点最多有两个子节点，通常被称作左子节点和右子节点。二叉树的定义严格说明了节点之间的层次结构，其中根节点位于顶层，每个子节点向下分为两个分支，每个分支都可能进一步扩展为二叉树。二叉树具有几个重要的性质：- 如果二叉树的高度为h，那么至少有h。
Java数据结构与算法——单向链表
贝尔摩德苦艾酒
03-11 6222
Java数据结构与算法——单向链表
深刻理解：带头结点和不带头结点的区别 使用头结点的优势
热门推荐
Code for Coffee
07-31 3万+
一、概念辨析 线性表的插入删除需要移动大量的元素，因此引入链表（本文讨论单链表）的概念，链表元素之间通过“链”来链接，因此插入和删除时不需要大量的移动元素，而只需要改变“链”的关系即可。 头指针：通常使用“头指针”来标识一个链表，如单链表L，头指针为NULL的时表示一个空链表。 头结点：在单链表的第一个结点之前附加一个结点，称为头结点。头结点的Data域可以不设任何信息，也可以记录表长等相关...
【数据结构】链表带头结点与不带头结点区别
Michael
06-19 1490
链表带头节点的实现中，在链表头部添加一个额外的节点作为哨兵节点，该节点不存储数据，只用于简化链表的操作。头指针指向哨兵节点，因此链表中的第一个节点为哨兵节点的下一个节点，这样在插入和删除节点时就不需要特别处理头指针，所有节点的操作都可以统一处理。链表不带头节点的实现中，第一个节点即为链表的头节点，因此在插入和删除节点时需要特别处理。但是，带头节点的实现会增加一个额外的节点，占用一定的内存空间。链表带头节点和不带头节点的区别在于： 是否在链表头部添加一个额外的节点作为哨兵节点。
单链表带头结点&不带头结点
weixin_30471561的博客
03-30 608
Node *head; //声明头结点 带头结点初始化 void InitList(Node **head){ *head=(Node *)malloc( sizeof(Node)); (*head)->next=NULL; } 带头结点尾插入，统一操作 方式一： void CreatList(Node **head){ Node *...
带头与不带头节点单链表
weixin_44501074的博客
10-12 2385
链表与顺序表、链表的一些常用方法
数据结构-单链表（带头结点与不带头结点表示）
Yyan7777的博客
02-13 4838
单链表是线性表的链式存取结构；是用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的；
【考研】分清带头结点和不带头结点的单链表
qq_34438969的博客
10-09 5397
为分清带结点与不带头结点的单链表操作，本文以图文和表格形式描述了两者之间的区别。考研中，数据结构的单链表操作是重要考点，其中，比较常考带头结点的链表操作。本文包含了带头结点的插入、删除、查找、用前插法和后插法创建单链表等基本操作。【考研】数据结构考点——直接插入排序_住在阳光的心里的博客-CSDN博客【考研】单链表相关算法（从基础到真题）_住在阳光的心里的博客-CSDN博客。
数据结构学习笔记——线性表的链式表示（单链表带头结点和不带头结点的基本操作）
小宇y的博客
04-10 9606
目录单链表的相关知识点（一）单链表的定义（二）单链表的初始化和空表判断（三）单链表的建立（四）单链表的输出（五）单链表的逆序输出（六）单链表的插入操作（七）单链表的删除操作（）（） 单链表的相关知识点 单链表是链式存储的，其每个结点除了存放数据元素之外，还存储指向下一个结点的指针；而顺序表是顺序存储的，其每个结点只存放数据元素。【顺序存储结构可以随机存取、顺序存取，而链式存储结构只能顺序存取】 顺序存储结构不仅可用于存储线性结构，还能用于树、图。 若需对表进行频繁的插入、删除操作，此时适合选链式存储。 一
链表(单向，双向，带头，不带头)
IT_涛涛
03-28 156
线性表的另一种表示方法—— 链式存储结构，由于它不要求逻辑上相邻的数据元素在物理位置上也相邻，因此它没有顺序存储结构所具有的弱点，但同时也失去了顺序表可随机存取的优点。
算法与数据结构之Floyd算法
最新发布
weixin_73953650的博客
06-20 397
超详细的Floyd算法教程，一看就懂！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值