数据结构与算法—链表之单链表

最新推荐文章于 2024-10-11 16:33:59 发布
最新推荐文章于 2024-10-11 16:33:59 发布
阅读量336 收藏
点赞数
分类专栏： 【数据结构与算法】 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32015565/article/details/128517267
版权

文章目录


2023年的第一篇文章

在开发过程中，选择合适的数据结构是很重要的，可以快速处理数据的存储及使用问题。计划有时间慢慢系统的学习《数据结构与算法》，看看视频，练习实践，最后用于工作中。

链表

单链表

结构和特点

链表是有序的列表，在内存中的存储结构如下：

特点：

  • 以节点的方式存储，是链式存储
  • 每个节点包含data域（用于存放数据），next域（指向下一个节点）
  • 链表的各个节点在内存中不一定是连续存储的
  • 链表分为带head节点和不带head节点的

链表的逻辑结构：

创建添加

因为链表是以节点存储，在创建链表时，就根据节点一个个添加连接起来。需要先创建一个head节点，根据head节点指向下一个节点，一个个串起来。

1、创建节点类

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 + '\'' +
                '}';
    }
}

2、有了节点类后，就可以创建head头结点，然后根据head节点，进行节点添加。

有两种添加方法，一种是顺序添加，另一种是根据英雄编号大小排序添加。

顺序添加：
在这里插入图片描述

// 创建一个单链表类，并添加操作
class SingleLickedList {
    // 创建头结点
    private HeroNode head = new HeroNode(0, "", "");

    // 添加节点到单链表
    public void add(HeroNode heroNode) {
        // 因为head节点不能动，需要一个辅助指针进行遍历 temp
        HeroNode temp = head;
        // 遍历链表，找到最后一个节点，添加新节点
        while (true) {
            // 找到最后一个节点，因为最后的节点的next域为NULL
            if (temp.next == null) {
                break;
            }
            // 没有找到，temp后移
            temp = temp.next;
        }

        // 当退出while 循环时，temp 就指向了最后一个节点
        temp.next = heroNode;
    }
}

有了添加操作，为了方便测试，需要能够遍历链表，打印出里面的数据。

在SingleLickedList 类中添加方法list

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);
        // 指针后移
        temp = temp.next;
    }
}

测试：

public static void main(String[] args) {
    // 创建节点
    HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
    HeroNode hero2 = new HeroNode(3, "李逵", "黑旋风");
    HeroNode hero3 = new HeroNode(2, "林冲", "豹子头");

    SingleLickedList list = new SingleLickedList();
    list.add(hero1);
    list.add(hero2);
    list.add(hero3);
    list.list();
}

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

可以看到正常添加完节点，并且按照添加的顺序显示。

有序添加：

就是在添加节点之前，查询是否有相同节点存在，如果存在，就不添加；查询下一个节点的编号no 是否大于需要添加节点的编号no，大于就表示要添加的节点就在下一个节点之前。

在这里插入图片描述

也就是根据节点的no ，有序的添加，创建方法 add2：

// 创建一个单链表类，并添加操作
class SingleLickedList {
    // 头结点
    private HeroNode head = new HeroNode(0, "", "");

    public void add2(HeroNode heroNode) {
        HeroNode temp = head;
        // 表示该节点是否找到相同编号的节点存在，false：未找到，true：找到
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                //
                break;
            }
            if (temp.next.no > heroNode.no) {
                // 找到了位置，应该放在temp之后
                break;
            } else if (temp.next.no == heroNode.no) {
                // 已经有相同节点
                flag = true;
                break;
            }
            // 指针后移
            temp = temp.next;
        }

        if (flag) {
            System.out.printf("待加入的英雄编号：%d已经有了", heroNode.no);
        } else {
            // 加入
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    // 添加节点到单链表
    public void add(HeroNode heroNode) {
        // 因为head节点不能动，需要一个辅助指针进行遍历 temp
        HeroNode temp = head;
        // 遍历链表，找到最后一个节点，添加新节点
        while (true) {
            // 找到最后一个节点，因为最后的节点的next域为NULL
            if (temp.next == null) {
                break;
            }
            // 没有找到，temp后移
            temp = temp.next;
        }

        // 当退出while 循环时，temp 就指向了最后一个节点
        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);
            // 指针后移
            temp = temp.next;
        }
    }
}

测试：

public static void main(String[] args) {
    // 创建节点
    HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
    HeroNode hero2 = new HeroNode(3, "李逵", "黑旋风");
    HeroNode hero3 = new HeroNode(2, "林冲", "豹子头");

    SingleLickedList list = new SingleLickedList();
    list.add(hero1);
    list.add(hero2);
    list.add(hero3);
    list.list();

    System.out.println("-------------------------");
    SingleLickedList list2 = new SingleLickedList();
    list2.add2(hero1);
    list2.add2(hero2);
    list2.add2(hero3);
    list2.list();
}

在这里插入图片描述

可以看到add2 所执行的是按顺序的

修改

根据节点数据的编号no，修该英雄的昵称nickname，创建方法 update

// 创建一个单链表类，并添加操作
class SingleLickedList {
    // 头结点
    private HeroNode head = new HeroNode(0, "", "");

    // 更新节点
    public void update(HeroNode heroNode) {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        HeroNode temp = head;
        boolean flag = false; //是否找到需要修改的节点
        while (true) {
            if (temp.next == null) {
                break; //已经遍历完链表
            }
            if (temp.next.no == heroNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }

        if (flag) {
            temp.next.nickName = heroNode.nickName;
        } else {
            System.out.println("没有相关节点");
        }
    }

    public void add2(HeroNode heroNode) {
        HeroNode temp = head;
        // 表示该节点是否找到相同编号的节点存在，false：未找到，true：找到
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                //
                break;
            }
            if (temp.next.no > heroNode.no) {
                // 找到了位置，应该放在temp之后
                break;
            } else if (temp.next.no == heroNode.no) {
                // 已经有相同节点
                flag = true;
                break;
            }
            // 指针后移
            temp = temp.next;
        }

        if (flag) {
            System.out.printf("待加入的英雄编号：%d已经有了", heroNode.no);
        } else {
            // 加入
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    // 添加节点到单链表
    public void add(HeroNode heroNode) {
        // 因为head节点不能动，需要一个辅助指针进行遍历 temp
        HeroNode temp = head;
        // 遍历链表，找到最后一个节点，添加新节点
        while (true) {
            // 找到最后一个节点，因为最后的节点的next域为NULL
            if (temp.next == null) {
                break;
            }
            // 没有找到，temp后移
            temp = temp.next;
        }

        // 当退出while 循环时，temp 就指向了最后一个节点
        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);
            // 指针后移
            temp = temp.next;
        }
    }
}

测试：

public static void main(String[] args) {
        // 创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(3, "李逵", "黑旋风");
        HeroNode hero3 = new HeroNode(2, "林冲", "豹子头");

        SingleLickedList list2 = new SingleLickedList();
        list2.add2(hero1);
        list2.add2(hero2);
        list2.add2(hero3);
        list2.list();

        // 测试更新节点
        System.out.println("------------------------");
        // 无相关节点
        list2.update(new HeroNode(4, "宋江", "梁上好汉"));
        list2.list();

        System.out.println("------------------------");
        // 修改成功
        list2.update(new HeroNode(1, "宋江", "梁上好汉"));
        list2.list();
}

在这里插入图片描述

删除

在这里插入图片描述

// 创建一个单链表类，并添加操作
class SingleLickedList {
    // 头结点
    private HeroNode head = new HeroNode(0, "", "");

    // 删除节点    这里可以根据需求将参数HeroNode 设置为只传入编号no即可
    public void delete(HeroNode heroNode) {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }

        HeroNode temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                 break;     // 已遍历完链表
            }

            if (temp.next.no == heroNode.no) {
                // 找到要删除的节点
                flag = true;
                break;
            }

            temp = temp.next;       // 指针后移
        }

        if (flag) {
            temp.next = temp.next.next;
        } else {
            System.out.println("没有相关节点");
        }

    }

    // 更新节点
    public void update(HeroNode heroNode) {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        HeroNode temp = head;
        boolean flag = false; //是否找到需要修改的节点
        while (true) {
            if (temp.next == null) {
                break; //已经遍历完链表
            }
            if (temp.next.no == heroNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }

        if (flag) {
            temp.next.nickName = heroNode.nickName;
        } else {
            System.out.println("没有相关节点");
        }
    }

    public void add2(HeroNode heroNode) {
        HeroNode temp = head;
        // 表示该节点是否找到相同编号的节点存在，false：未找到，true：找到
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                //
                break;
            }
            if (temp.next.no > heroNode.no) {
                // 找到了位置，应该放在temp之后
                break;
            } else if (temp.next.no == heroNode.no) {
                // 已经有相同节点
                flag = true;
                break;
            }
            // 指针后移
            temp = temp.next;
        }

        if (flag) {
            System.out.printf("待加入的英雄编号：%d已经有了", heroNode.no);
        } else {
            // 加入
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    // 添加节点到单链表
    public void add(HeroNode heroNode) {
        // 因为head节点不能动，需要一个辅助指针进行遍历 temp
        HeroNode temp = head;
        // 遍历链表，找到最后一个节点，添加新节点
        while (true) {
            // 找到最后一个节点，因为最后的节点的next域为NULL
            if (temp.next == null) {
                break;
            }
            // 没有找到，temp后移
            temp = temp.next;
        }

        // 当退出while 循环时，temp 就指向了最后一个节点
        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);
            // 指针后移
            temp = temp.next;
        }
    }
}

测试：

public static void main(String[] args) {
        // 创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(3, "李逵", "黑旋风");
        HeroNode hero3 = new HeroNode(2, "林冲", "豹子头");

        // 测试删除
        SingleLickedList list = new SingleLickedList();
        list.add(hero1);
        list.add(hero2);
        list.add(hero3);
        System.out.println("删除数据前的链表~~~~~~");
        list.list();

        System.out.println("删除数据后的链表~~~~~~");
        list.delete(new HeroNode(3, "李逵", "黑旋风"));
        list.list();

        System.out.println("删除数据后的链表~~~~~~");
        list.delete(new HeroNode(1, "宋江", "及时雨"));
        list.delete(new HeroNode(2, "林冲", "豹子头"));
        list.list();
    }

在这里插入图片描述

删除完数据后，链表就为空

到这，暂时学习了单链表的增删改查。

可以看看我的个人博客：
网站：https://www.fuzm.wang / https://liwangc.gitee.io
—————————————————————————

作为初学者，很多知识都没有掌握，见谅，如有错误请指出，以期进步，感谢！。后续有新的学习，继续补充上来。

liwangC
关注
专栏目录
【数据结构】——单链表
qq_43412060的博客
07-17 388
1、链表的概念和分类 2、单链表的结构 3、单链表的具体操作实现 3、源码
Python实现数据结构线性链表（单链表）算法示例
12-26
本文实例讲述了Python实现数据结构线性链表（单链表）算法。分享给大家供大家参考，具体如下： 初学python，拿数据结构中的线性链表存储结构练练手，理论比较简单，直接上代码。 #!/usr/bin/python # -*- coding:...
数据结构与算法-反转单链表
weixin_42560424的博客
05-29 431
在介绍问题之前，我们先简单了解一下单链表。单链表是一种线性数据结构，由一系列节点组成，每个节点包含两个部分：存储数据的部分和指向下一个节点的指针。链表的第一个节点称为头节点，最后一个节点的指针指向null，表示链表的结束。
数据结构与算法——线性表（链表篇）
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
[数据结构]链表之单链表（详解）
m0_63123468的博客
03-28 1万+
[数据结构]链表之单链表的详细解析
数据结构与算法——单链表的逆序
icc_hhy的博客
05-21 1352
在之前，了解了单链表结点的删除和插入之后，大家会发现这种具有方向性的链表结构中增删结点是相当容易的一件事。要从头到尾输出整个单链表也不难，但是如果要反转过来输出单向链表就需要某些技巧了。单向链表的结点特性就是知道下一个结点的位置，可是却无法得知它上一个结点的位置。因此下面将介绍2中方法来实现单链表的逆序操作。
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
【数据结构与算法】对单链表实现就地逆置
知识虔诚的信徒，探索所有未知是信徒毕生的信仰
03-22 3357
用C语言实现单链表就地逆置算法
数据结构之链表——单链表的逆置
weixin_64495476的博客
07-06 1057
【代码】数据结构之链表——单链表的逆置。
[数据结构与算法] 线性表之单链表初始化详解
淋曦的进击手记
08-21 2546
根据数据的存储结构，数据结构可分为数组和链表。数组：连续的内存空间。链表：离散的内存空间。链表通过指针将一组离散的内存块串联在一起。每个内存块称为链表的节点，每个节点包含数据域和指针域。单链表通过任意的存储单元存储线性表中的数据元素，每个节点由数据域和指针域两部分组成，如下图，其中data为数据域，存放数据元素，next为指针域，存放其直接后继节点的地址。链表，一定要保证尾节点的指针置空。每一个节点要至少被一个指针指向。
【数据结构与算法】 01 链表 （单链表、双向链表、循环链表、块状链表、头结点、链表反转与排序、约瑟夫环问题）
风高秋月白，雨霁晚霞红
06-07 1万+
单链表、双向链表、循环链表、块状链表、头结点、链表反转与排序、约瑟夫环问题
《数据结构与算法》课程上机实验二（链表）_链表_fruitd55_C++_数据结构与算法_
10-04
在计算机科学中，数据结构与算法是至关重要的基础，它们直接影响到程序的效率和性能。本次上机实验主要关注的是链表，一种常用的数据结构，它在C++中有着广泛的应用。链表不同于数组，其元素不是连续存储的，而是...
用VC编写单链表(数据结构).rar_VC 链表_单链表_数据结构 链表_链表
09-21
对于初学者来说，这是一个很好的起点，因为链表是许多高级数据结构和算法的基础，如双向链表、循环链表、队列和栈等。同时，理解和掌握链表有助于提升编程能力，特别是在处理动态数据集和优化内存使用方面。
【数据结构】双向链表（Doubly Linked List）
2301_77727857的博客
10-05 565
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
数据结构之图（6）
2301_76246515的博客
10-05 994
图G有顶点集V和边集E组成，记为G=(V,E),其中V（G）表示图G中顶点的有限非空集；E(G)表示图G中顶点之间的关系（边）集合。若V={v1,v2,…，vn}，则用|V|表示图G中顶点的个数。也称为图G的阶E={（u,v)|u ∈​​​V},用|E|表示图G中边的条数图不可以是空，V一定是非空集E是无向边（简称边）的有限集合E是有向边（弧）的有限集合弧是顶点的有序对，记为<v,w>,v为弧尾，w为弧头不存在重复边不存在顶点到自身的边。
C语言 动态数据结构的C语言实现内存映像
hangweijie的博客
10-04 407
在程序运行期间，用动态内存分配函数来申请的内 存都是从堆上分配的，动态内存的生存期由程序员 自己来决定。在执行函数调用时，系统在栈上为函数内的局部变 量及形参分配内存，函数执行结束时，自动释放这 些内存。在执行函数调用时，系统在栈上为函数内的局部变 量及形参分配内存，函数执行结束时，自释放这 些内存。存放函数参数值，局部变量值等。存放函数参数值，局部变量值等。C程序中变量的内存分配方式。C程序中变量的内存分配方式。C程序中变量的内存分配方式。C程序中变量的内存分配方式。
浙大数据结构：08-图9 关键活动
最新发布
qq_74924951的博客
10-11 240
拓扑排序找关键活动
【数据结构 | PTA】表
等风来
10-08 764
例如给定 L 为 21→-15→-15→-7→15，你需要输出去重后的链表 21→-15→-7，还有被删除的链表 -15→15。输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−1表示序列的结尾（−1不属于这个序列）。输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−1表示序列的结尾（−1不属于这个序列）。已知两个非降序链表序列S1与S2，设计函数构造出S1与S2合并后的新的非降序链表S3。对每个测试用例，顺序输出重排后的结果链表，其上每个结点占一行，格式与输入相同。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值