数据结构_链表_链表的快速实现

已于 2023-10-24 23:26:22 修改
阅读量76 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表 java 1024程序员节
于 2023-10-24 23:23:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41958629/article/details/134024182
版权

文章目录

0. 相关文章

数据结构_链表_初识链表

1. 单向链表

1.1 定义链表节点和display方法

我们已经知道，单向链表是由数据和指向下一个节点的指针（引用）组成。下面我们先定义一个学生信息的链表，包括"学生信息"及“指向下一个节点的指针”

@Data
public class StudentNode {
    /**
     * 学生信息
     */
    public Student stu;

    /**
     * 指向下一个节点的指针
     */
    public StudentNode next;

    /**
     * 提供一个构造方法，引用默认为null
     *
     * @param stu 学生信息
     */
    StudentNode(Student stu) {
        this.stu = stu;
        this.next = null;
    }
}

@NoArgsConstructor
@AllArgsConstructor
@Data
public class Student {
    /**
     * 学号
     */
    public Long number;

    /**
     * 姓名
     */
    public String name;

    /**
     * 成绩
     */
    public Integer grade;
}

下面我们先提供一个遍历链表的方法，以便于我们后续观测结果。有之前的知识我们可以知道单向链表的 next 指针指向它的下一个节点，那么如果判断已经到尾节点了呢？那就是 next==null 时，代表该单向链表已经没有下一个节点了。
在这里插入图片描述

public static void display(StudentNode head) {
    // 定义tempNode：使用该变量进行遍历
    StudentNode tempNode = head;
    // 定义变量i，记录第几个节点
    int i = 1;

    System.out.println("开始打印链表...");
    // while循环遍历，从头节点一直遍历到尾节点（尾节点：next==null）
    while (tempNode != null) {
        // 打印节点信息
        System.out.printf("第%d个节点，node=%s%n", i, tempNode.stu);
        // 获取下一个节点信息
        tempNode = tempNode.getNext();
        // i++，记录当前是第几个节点
        i++;
    }
    System.out.println("链表打印完成...");
}

2.2 插入节点

插入节点我们肯定能想到有两种方式
● 在某个节点的后面插入一个节点
● 在某个节点的前面插入一个节点

在某个节点的后面插入一个节点：
让我们以一个实际的例子来看看，例如我们有这么一条链表（张三 -> 李四 -> 王五），现在想要把"赵六"插入到张三的后面，如下图
在这里插入图片描述
由上图我们可以分析得到：我们总共需要完成两步操作即可完成插入操作：把张三的 next 指针指向赵六；把赵六的 next 指针指向李四。

那么就有两种方案可以完成
● 先“张三.next = 赵六”；后“赵六.next = 李四”
● 先“赵六.next = 李四”；后“张三.next = 赵六”

方案 一：我们先把张三的 next 指针指向赵六，但此时我们会发现有一个问题，那就是我们找不到李四的位置了。（链表的遍历都是由当前节点的 next 找到后一个节点）如果实在要使用这种方案，我们应该再加上一步"保存李四的位置"。但是由于比较麻烦，所以我们一般不使用。
在这里插入图片描述

方案二：我们先将赵六的 next 节点指向李四，然后再讲张三的 next 节点指向赵六
在这里插入图片描述

下面来看看代码实现：

/**
 * 在当前节点后面插入一个节点
 *
 * @param curNode 当前节点
 * @param operateNode 待插入的节点
 * @return 是否插入成功
 */
public static boolean addAfter(StudentNode curNode, StudentNode operateNode) {
    // 1. 如果"当前节点"或"待插入的节点"为null，直接返回false
    if (curNode == null || operateNode == null) {
        return false;
    }

    // 2. operateNode的next指针指向curNode的后一个节点
    operateNode.next = curNode.next;

    // 3. curNode的next指针指向operateNode节点
    curNode.next = operateNode;

    // 4. 插入成功返回true
    return true;
}

此时我们的需求是将"赵六"插入到"张三"的后面，因此 curNode=张三，operateNode=赵六

  1. 非空判断，这里就不过多描述
  2. operateNode.next = curNode.next;我们首先需要将赵六的 next 节点指向李四，即 “operateNode.next=李四”，李四我们怎么获取呢？有链表我们可以知道，李四在张三的后一个节点因此“李四=curNode.next”。
  3. curNode.next = operateNode;这一步非常好理解，即张三的 next 节点指向赵六
  4. 不做过多描述

下面我们写一个程序来验证一下

public class Demo {
    public static void main(String[] args) {
        testAddAfter();
    }

    public static void testAddAfter() {
        // 1. 构造初始链表
        StudentNode zhang3 = new StudentNode(new Student(20230003L, "张三", 93));
        StudentNode li4 = new StudentNode(new Student(20230004L, "李四", 94));
        StudentNode wang5 = new StudentNode(new Student(20230005L, "王五", 95));
        zhang3.next = li4;
        li4.next = wang5;

        // 2. 打印插入前的链表
        System.out.println("------------------打印插入前的链表-----------------");
        StudentListUtil.display(zhang3);

        // 3. 初始化赵六节点并插入
        StudentNode zhao6 = new StudentNode(new Student(20230006L, "赵六", 96));
        StudentListUtil.addAfter(zhang3, zhao6);

        // 4. 打印插入后的链表
        System.out.println("------------------打印插入后的链表-----------------");
        StudentListUtil.display(zhang3);
    }
}

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


在某个节点的前面插入一个节点：
在单向链表中，由于无法从后一个节点找到前一个节点，因此想要实现在某个节点的前面插入比较的困难。

让我们还是来看看上一个栗子，例如我们有这么一条链表（张三 -> 李四 -> 王五），现在想要把"赵六"插入到李四的前面，如下图
在这里插入图片描述

具体的实现步骤为：

  1. 赵六的 next 指向李四
  2. 遍历链表，找到李四的前一个节点，即张三
  3. 张三的 next 指向赵六

在这里插入图片描述

/**
 * 在当前节点后面插入一个节点
 *
 * @param head 头节点
 * @param curNode 当前节点
 * @param operateNode 待插入的节点
 * @return 是否插入成功
 */
public static boolean addBefore(StudentNode head, StudentNode curNode, StudentNode operateNode) {
    // 1. 如果"头节点"或"当前节点"或"待插入的节点"为null，直接返回false
    if (head == null || curNode == null || operateNode == null) {
        return false;
    }

    // 2. 将待操作的节点的next指针指向curNode
    operateNode.next = curNode;
    
    // 3. 遍历链表，找到curNode的前一个节点
    StudentNode prevNode = head;
    while (prevNode != null) {
        if (prevNode.next == curNode) {
            break;
        }
        prevNode = prevNode.next;
    }
    // 如果 prevNode == null，即没有匹配到节点，while循环因为不满足循环条件而退出，所以返回false；
    if (prevNode == null) {
        return false;
    }

    // 4. prevNode的next指针指向operateNode
    prevNode.next = operateNode;

    // 5. 插入成功返回true
    return true;
}

！！！注意：如果是在头节点的前面插入一个节点，此时头节点就会发生改变，需要修改头节点的值，避免出错。

验证程序与执行结果：

public class Demo {
    public static void main(String[] args) {
        testAddBefore();
    }

    public static void testAddBefore() {
        // 1. 构造初始链表
        StudentNode zhang3 = new StudentNode(new Student(20230003L, "张三", 93));
        StudentNode li4 = new StudentNode(new Student(20230004L, "李四", 94));
        StudentNode wang5 = new StudentNode(new Student(20230005L, "王五", 95));
        zhang3.next = li4;
        li4.next = wang5;

        // 2. 打印插入前的链表
        System.out.println("------------------打印插入前的链表-----------------");
        StudentListUtil.display(zhang3);

        // 3. 初始化赵六节点并插入
        StudentNode zhao6 = new StudentNode(new Student(20230006L, "赵六", 96));
        StudentListUtil.addBefore(zhang3, li4, zhao6);

        // 4. 打印插入后的链表
        System.out.println("------------------打印插入后的链表-----------------");
        StudentListUtil.display(zhang3);
    }
}

在这里插入图片描述

2.3 删除节点

场景 1：删除头节点
此时直接将头节点的 next 设置为 head 即可
在这里插入图片描述

场景 2：删除非头节点
此时我们将前一个节点的 next 指针指向后一个节点即可
在这里插入图片描述

/**
 * 删除节点
 *
 * @param head 头节点
 * @param operateNode 待删除的节点
 * @return 更新后的头节点位置
 */
public static StudentNode deleteNode(StudentNode head, StudentNode operateNode) {
    // 1. 如果"头节点"或"待删除的节点"为null，删除无意义，直接返回原头节点
    if (head == null || operateNode == null) {
        return head;
    }

    // 2. 如果删除的是头结点，直接返回下一个节点作为头节点
    if (head == operateNode) {
        return head.next;
    }

    // 3. 遍历链表，找到curNode的前一个节点
    StudentNode prevNode = head;
    while (prevNode != null) {
        if (prevNode.next == operateNode) {
            break;
        }
        prevNode = prevNode.next;
    }
    
    // 4. 如果 prevNode == null，即没有匹配到节点，while循环因为不满足循环条件而退出
    //    此时删除无意义，直接返回head。
    if (prevNode == null) {
        return head;
    }

    // 5. prevNode的next指针指向operateNode的next
    prevNode.next = operateNode.next;
    return head;
}

验证程序与执行结果：

public class Demo {
    public static void main(String[] args) {
        testDelete();
    }

    public static void testDelete() {
        // 1. 构造初始链表
        StudentNode zhang3 = new StudentNode(new Student(20230003L, "张三", 93));
        StudentNode li4 = new StudentNode(new Student(20230004L, "李四", 94));
        StudentNode wang5 = new StudentNode(new Student(20230005L, "王五", 95));
        zhang3.next = li4;
        li4.next = wang5;

        // 2. 打印插入前的链表
        System.out.println("------------------打印插入前的链表-----------------");
        StudentListUtil.display(zhang3);

        // 3. 删除li4
        StudentNode head = StudentListUtil.deleteNode(zhang3, li4);

        // 4. 打印插入后的链表
        System.out.println("------------------打印插入后的链表-----------------");
        StudentListUtil.display(head);
    }
}

在这里插入图片描述

3. 双向链表

待更新…

去码头整点薯条吧m
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构_静态链表(C语言)
小黯
04-02 3299
目录一、静态链表图文解析二、静态链表代码解析1、基本操作1.1 结构1.2 初始化1.3 插入数据1.4 删除数据1.5 修改数据2、源代码及测试2.1 源代码2.2 测试结果 一、静态链表图文解析 二、静态链表代码解析 1、基本操作 1.1 结构 1.2 初始化 1.3 插入数据 1.4 删除数据 1.5 修改数据 2、源代码及测试 2.1 源代码 2.2 测试结果 ...
数据结构-链表结构-双向链表
qq_44715376的博客
08-01 3288
双向链表
数据结构：链表及其C++实现
forGemini的博客
05-26 1万+
前言 链表是一种非常非常基础的数据结构，本文首先讲解链表的基础知识，然后使用C++的模板实现了一个链表类，并简单实现了常见的插入、删除、查找等算法。 阅读本文需要对C/C++的指针具有一定的了解。 基础知识 链表是一种逻辑上连续，内存上分散的线性表数据结构，其基本单位为结点，每个结点分数据区和指针区，数据区用于存放数据，指针区则用于指向其他结点，通过指针每个结点就被串接成了一条“链子”。
数据结构之链表（Java实现）
Easenyang的博客
05-18 8085
数据结构中线性表的重要知识之一
【数据结构】链表
knous
03-13 6万+
链表
数据结构之链表(java语言实现)
LNsupermali的博客
12-28 2695
数据结构之链表(java语言实现)
C语言链表超详解
热门推荐
k666499436的博客
05-17 10万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
数据结构——C语言实现链表
theonly_Love的博客
05-22 1万+
一. 链表的概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。在这里介绍链表中的两种结构
java数据结构-链表详解
m0_63526467的博客
05-04 3993
文章目录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
数据结构之链表
喜欢捣鼓各种技术
01-18 3898
数据结构之链表
数据结构_链表的分类_数据结构_
10-02
数据结构C语言的入门，数据链表的分类，能够帮助你学习数据结构
数据结构_队列_链表1
08-03
数据结构_队列_链表1
shujujiegou.rar_c 数据结构_数据结构_栈_链表 实现_顺序表
09-22
数据结构源程序，包括：顺序表的基本运算实现，链表的基本运算与实现，栈的基本运算与实现以及实例等18个源程序。
C语言演示链表操作.rar_C语言_双向循环链表_数据结构_链表 list_链表操作
09-19
数据结构的链表关系，用TC2.0 编写，比较完整，可以作为学生的教学用
ds_lab_3_链表_链表操作_数据结构_
10-02
使用C语言实现了基本的链表操作，为处理链式结构的数据提供支持。
鸿蒙轻内核A核源码分析系列二 数据结构-位图操作
最新发布
maniuT的博客
06-11 1043
位操作模块提供对32位无符号整数数值的bit位进行操作，bit位取值为0-31，以0开始计算，从左向右，第0位，第1位。。。第31位等。⑴处定义的宏如下，也就是十进制31。如果传入的比特位pos大于31，会通过逻辑与运算截断，只取低5位，确保不会大于31，避免溢出。⑵处定义的位图掩码全是1。在文件中定义了常用的位操作相关的宏。宏根据参数x计算出需要操作第几个状态字，由于计算状态字的使用的是UINTPTR，状态字可以是32位、也可以是64位。后文，我们默认以32位进行讲解。宏传入的参数是位操作的开始bit。
数据结构--第七章--树和二叉树
2302_80052051的博客
06-11 316
前序+中序可以确定一个二叉树；中序+后序可以确定一个二叉树。，将数据元素组织成层次结构，元素间属于。二叉树的定义是递归定义。
数据结构--线性表和串
code袁的博客
06-08 817
🦁作者简介：一名喜欢分享和记录学习的在校大学生💥个人主页code袁💥个人QQ🐯个人wechat：code8896线性表是一种常见的数据结构，它是具有相同数据类型的有限序列。线性表中的元素之间存在一种顺序关系，可以通过元素在表中的位置来访问和操作。串是由零个或多个字符组成的有限序列，也可以理解为字符串。串是计算机科学中最基本的数据类型之一，常用于表示文本信息。手动码字，如有错误，欢迎在评论区指正💬~你的支持就是我更新的最大动力💪~
数据结构 -- 树状数组
gghhb12的博客
06-09 1303
树状数组或二叉索引树（Binary Indexed Tree），又以其发明者命名为 Fenwick 树。其初衷是解决数据压缩里的累积频率的计算问题，现多用于高效计算数列的前缀和、区间和。它可以以 O(logn) 的时间得到任意前缀和。并同时支持在 O(logn) 时间内支持动态单点值的修改。空间复杂度 O(n)。具体区别和联系如下：1.两者在复杂度上同级, 但是树状数组的常数明显优于线段树, 其编程复杂度也远小于线段树.
数据结构用链表实现多项式相加
06-07
对于两个多项式 $A(x)$ 和 $B(x)$，我们可以将它们表示为以下形式： $$ A(x) = a_n x^n + a_{n-1} x^{n-1} + \cdots + a_1 x + a_0 $$ $$ B(x) = b_m x^m + b_{m-1} x^{m-1} + \cdots + b_1 x + b_0 $$ 其中 $n$ 和 $m$ 分别表示两个多项式的最高次幂，$a_i$ 和 $b_j$ 分别表示 $x^i$ 和 $x^j$ 的系数。 我们可以将两个多项式相加，得到一个新的多项式 $C(x)$： $$ C(x) = A(x) + B(x) = c_k x^k + c_{k-1} x^{k-1} + \cdots + c_1 x + c_0 $$ 其中 $k = \max(n, m)$，$c_i = a_i + b_i$。 为了实现多项式相加，我们可以用链表来存储多项式。链表的每个节点表示一个单项式，包含系数和次数两个属性。具体地，我们可以设计一个结构体来表示单项式： ```c++ struct Node { int coef; // 系数 int exp; // 次数 Node* next; // 指向下一个节点的指针 }; ``` 然后，我们可以用一个链表来表示一个多项式，链表的每个节点存储一个单项式。链表的头指针指向第一个节点，尾指针指向最后一个节点。具体地，我们可以设计一个结构体来表示多项式： ```c++ struct Poly { Node* head; // 指向第一个节点的指针 Node* tail; // 指向最后一个节点的指针 }; ``` 接下来，我们可以实现一个函数来创建一个多项式。这个函数会从标准输入中读取多项式的每个单项式，然后将其添加到链表中。具体地，我们可以设计一个函数如下： ```c++ Poly create_poly() { Poly poly; poly.head = poly.tail = nullptr; // 初始化链表为空 int coef, exp; while (cin >> coef >> exp) { Node* node = new Node{coef, exp, nullptr}; if (poly.tail == nullptr) { poly.head = poly.tail = node; } else { poly.tail->next = node; poly.tail = node; } } return poly; } ``` 最后，我们可以实现一个函数来计算两个多项式的和。这个函数会遍历两个链表，将每个单项式相加，然后将其添加到结果链表中。具体地，我们可以设计一个函数如下： ```c++ Poly add_poly(const Poly& poly1, const Poly& poly2) { Poly res; res.head = res.tail = nullptr; // 初始化链表为空 Node *p1 = poly1.head, *p2 = poly2.head; while (p1 != nullptr && p2 != nullptr) { if (p1->exp > p2->exp) { Node* node = new Node{p1->coef, p1->exp, nullptr}; if (res.tail == nullptr) { res.head = res.tail = node; } else { res.tail->next = node; res.tail = node; } p1 = p1->next; } else if (p1->exp < p2->exp) { Node* node = new Node{p2->coef, p2->exp, nullptr}; if (res.tail == nullptr) { res.head = res.tail = node; } else { res.tail->next = node; res.tail = node; } p2 = p2->next; } else { Node* node = new Node{p1->coef + p2->coef, p1->exp, nullptr}; if (res.tail == nullptr) { res.head = res.tail = node; } else { res.tail->next = node; res.tail = node; } p1 = p1->next; p2 = p2->next; } } while (p1 != nullptr) { Node* node = new Node{p1->coef, p1->exp, nullptr}; if (res.tail == nullptr) { res.head = res.tail = node; } else { res.tail->next = node; res.tail = node; } p1 = p1->next; } while (p2 != nullptr) { Node* node = new Node{p2->coef, p2->exp, nullptr}; if (res.tail == nullptr) { res.head = res.tail = node; } else { res.tail->next = node; res.tail = node; } p2 = p2->next; } return res; } ``` 这样，我们就实现了用链表来表示多项式，并且计算两个多项式的和。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值