带头节点单链表（Linked List）底层增删改查原理

最新推荐文章于 2022-08-06 22:49:41 发布
最新推荐文章于 2022-08-06 22:49:41 发布
阅读量416 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44009447/article/details/118433013
版权

Java 链表 单链表 增删改查 数据结构
关键词由CSDN通过智能技术生成

文章目录

一。简介

链表是有序的列表，它在内存中的存储方式如下：
在这里插入图片描述

  • 链表是以节点的方式来存储，是链式存储
  • 每个节点包含data域，next域：指向下一个节点，当某个节点的next==null时表示该节点为最后一个节点
  • 链表的各个节点不一定是连续存储，而是通过类似于指针的方式，让本身的next域指向下一个节点，从而做到链表读取
  • 链表分带头节点的链表和没有带头节点的链表，根据实际的需求来确定

单链表逻辑结构示意图如下：
在这里插入图片描述

二。应用实例

使用带head头的单向链表实现 –水浒英雄排行榜管理
在这里插入图片描述

  1. 完成对英雄人物的增删改查操作
  2. 第一种方式在添加英雄时，直接添加到链表的尾部
  3. 第二种方式在添加英雄时，根据排名将英雄插入到指定位置(如果有这个排名，则添加失败，并给出提示)

1.初始化英雄节点以及单链表

/**
 * @author Keson
 * @version 1.0
 * @description: TODO
 * @date 2021/7/3 7:10
 */
public class SingleLinkedListDemo {

    //先定义一个英雄的节点类
    class HeroNode{
        private int id;//唯一id编号
        private String name;//真实姓名
        private String nickName;//昵称
        private HeroNode next;//模拟单链表的next域：指向下一个节点

        //构造器
        public HeroNode(int id,String name,String nickName){
            this.id=id;
            this.name=name;
            this.nickName=nickName;
        }
        
    }

    class SingleLinkedList{
        //先初始化一个头节点, 头节点不要动, 不存放具体的数据
        private HeroNode head = new HeroNode(0, "", "");

        //无序添加方式(不考虑编号顺序时)
       
        //有序添加方式(考虑编号顺序时)

        //修改

        //删除

        //显示
    }
}

2.无序添加

实现思路：

  1. 先创建一个head 头节点， 作用就是表示单链表的头
  2. 后面我们每添加一个节点，就直接加入到链表的最后
  3. 通过一个辅助变量遍历，帮助遍历整个链表
    在这里插入图片描述

SingleLinkedList（添加无序插入以及遍历显示方法）：

//定义一个单链表存储英雄节点信息
    static class SingleLinkedList{
        //先初始化一个头节点, 头节点不要动, 不存放具体的数据
        private HeroNode head = new HeroNode(0, "", "");

        //无序添加方式(不考虑编号顺序时)
        //1. 找到当前链表的最后节点
        //2. 将最后这个节点的next指向新的节点
        public void add(HeroNode heroNode){
            //因为头节点是不能动的，所以需要初始化一个辅助变量来实现遍历（类似于指针）
            HeroNode temp = head;
            //遍历链表，找到最后
            while(true) {
                //找到链表的最后（空链表的情况）
                if(temp.next == null) {
                    break;
                }
                //如果没有找到最后, 将temp后移
                temp = temp.next;
            }
            //当退出while循环时，temp就指向了链表的最后
            //将最后这个节点的next指向新的节点
            temp.next = heroNode;
        }
        //有序添加方式

        //修改

        //删除

        //遍历链表
        public void list(){
            //判断链表是否为空
            if(head.next == null){
                System.out.print("该链表为空！");
            }
            //因为头节点是不能动的，所以需要初始化一个辅助变量来实现遍历（类似于指针）
            HeroNode temp = head.next;
            while(true){
                if(temp == null){
                    break;
                }
                //输出节点的信息
                System.out.println(temp);
                //指针后移
                temp = temp.next;
            }
        }
    }

HeroNode（重写toString方法）：

        @Override
        public String toString() {
            return "HeroNode{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", nickName='" + nickName + '\'' +
                    '}';
        }

主程序入口：

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

        //显示链表元素
        singleLinkedList.list();
    }

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

3.有序添加

实现思路：

  1. 首先找到新添加的节点的位置, 是通过辅助变量(指针), 通过遍历来搞定
  2. 新的节点.next = temp.next
  3. 将temp.next = 新的节点

在这里插入图片描述
SingleLinkedList（添加有序插入）：

//有序添加方式(考虑编号顺序时)
public void addByOrder(HeroNode heroNode){
    //因为头节点是不能动的，所以需要初始化一个辅助变量来实现遍历（类似于指针）
    HeroNode temp = head;
    boolean flag = false;//判断编号是否存在标志
    while (true) {
        //如果链表为空
        if(temp.next == null){
            break;
        }
        //找到插入位置
        if(temp.next.id > heroNode.id){
            break;
        }else if(temp.next.id == heroNode.id){
            flag = true; //说明编号存在
            break;
        }
        //继续进行遍历
        temp = temp.next;
    }

    //判断flag 的值
    if(flag) { //不能添加，说明编号存在
        System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", heroNode.id);
    } else {
        //插入到链表中, temp的后面
        heroNode.next = temp.next;
        temp.next = heroNode;
    }
}

主程序入口：

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

    //有序加入
    singleLinkedList.addByOrder(hero1);
    singleLinkedList.addByOrder(hero4);
    singleLinkedList.addByOrder(hero2);
    singleLinkedList.addByOrder(hero3);

    //显示链表元素
    singleLinkedList.list();
}

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

4.修改

实现思路：

根据编号找到需要修改的节点, 修改该节点信息即可。

SingleLinkedList（添加更新操作）：

//修改
public void update(HeroNode heroNode){
    //因为头节点是不能动的，所以需要初始化一个辅助变量来实现遍历（类似于指针）
    HeroNode temp = head.next;
    boolean flag = false;//判断编号是否存在标志
    while(true){
        //如果链表为空
        if(temp == null){
            System.out.print("该链表为空！");
            break;
        }
        //如果找到需要修改的节点
        if(temp.id == heroNode.id){
            flag = true;
            break;
        }
        //继续进行遍历
        temp = temp.next;
    }

    //修改属性
    if(flag){
        temp.name = heroNode.name;
        temp.nickName = heroNode.nickName;
    }else { //没有找到
        System.out.printf("没有找到 编号 %d 的节点，不能修改\n", heroNode.id);
    }
}

主程序入口：

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

        //有序加入
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        //显示链表元素
        singleLinkedList.list();

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

        System.out.println("修改后的链表情况~~");
        singleLinkedList.list();
    }

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

5.删除

实现思路：

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

在这里插入图片描述
SingleLinkedList（添加删除操作）：

//删除
public void remove(int id){
    //因为头节点是不能动的，所以需要初始化一个辅助变量来实现遍历（类似于指针）
    HeroNode temp = head;
    boolean flag = false;//判断是否找到需要删除的节点标志
    while(true){
        //如果链表为空
        if(temp.next == null){
            System.out.print("该链表为空！");
            break;
        }
        //如果找到需要删除的节点
        if(temp.next.id == id){
            flag = true;
            break;
        }
        //继续进行遍历
        temp = temp.next;
    }
    //判断flag
    if(flag){
        temp.next = temp.next.next;
    }else {
        System.out.printf("要删除的 %d 节点不存在\n", id);
    }
}

主程序入口：

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

        //有序加入
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        //显示链表元素
        singleLinkedList.list();

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

        System.out.println("修改后的链表情况~~");
        singleLinkedList.list();*/

        //删除一个节点
        singleLinkedList.remove(1);
        singleLinkedList.remove(4);
        System.out.println("删除后的链表情况~~");
        singleLinkedList.list();
    }

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

三。完整代码

/**
 * @author Keson
 * @version 1.0
 * @description: TODO
 * @date 2021/7/3 7:10
 */
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(hero4);
//        singleLinkedList.add(hero2);
//        singleLinkedList.add(hero3);

        //有序加入
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        //显示链表元素
        singleLinkedList.list();

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

        System.out.println("修改后的链表情况~~");
        singleLinkedList.list();*/

        //删除一个节点
        singleLinkedList.remove(1);
        singleLinkedList.remove(4);
        System.out.println("删除后的链表情况~~");
        singleLinkedList.list();
    }

    //先定义一个英雄的节点类
    static class HeroNode{
        private int id;//唯一id编号
        private String name;//真实姓名
        private String nickName;//昵称
        private HeroNode next;//模拟单链表的next域：指向下一个节点

        //构造器
        public HeroNode(int id,String name,String nickName){
            this.id=id;
            this.name=name;
            this.nickName=nickName;
        }


        @Override
        public String toString() {
            return "HeroNode{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", nickName='" + nickName + '\'' +
                    '}';
        }
    }

    //定义一个单链表存储英雄节点信息
    static class SingleLinkedList{
        //先初始化一个头节点, 头节点不要动, 不存放具体的数据
        private HeroNode head = new HeroNode(0, "", "");

        //无序添加方式(不考虑编号顺序时)
        //1. 找到当前链表的最后节点
        //2. 将最后这个节点的next指向新的节点
        public void add(HeroNode heroNode){
            //因为头节点是不能动的，所以需要初始化一个辅助变量来实现遍历（类似于指针）
            HeroNode temp = head;
            //遍历链表，找到最后
            while(true) {
                //找到链表的最后（空链表的情况）
                if(temp.next == null) {
                    break;
                }
                //如果没有找到最后, 将temp后移
                temp = temp.next;
            }
            //当退出while循环时，temp就指向了链表的最后
            //将最后这个节点的next指向新的节点
            temp.next = heroNode;
        }

        //有序添加方式(考虑编号顺序时)
        public void addByOrder(HeroNode heroNode){
            //因为头节点是不能动的，所以需要初始化一个辅助变量来实现遍历（类似于指针）
            HeroNode temp = head;
            boolean flag = false;//判断编号是否存在标志
            while (true) {
                //如果链表为空
                if(temp.next == null){
                    break;
                }
                //找到插入位置
                if(temp.next.id > heroNode.id){
                    break;
                }else if(temp.next.id == heroNode.id){
                    flag = true; //说明编号存在
                    break;
                }
                //继续进行遍历
                temp = temp.next;
            }

            //判断flag 的值
            if(flag) { //不能添加，说明编号存在
                System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", heroNode.id);
            } else {
                //插入到链表中, temp的后面
                heroNode.next = temp.next;
                temp.next = heroNode;
            }
        }


        //修改
        public void update(HeroNode heroNode){
            //因为头节点是不能动的，所以需要初始化一个辅助变量来实现遍历（类似于指针）
            HeroNode temp = head.next;
            boolean flag = false;//判断编号是否存在标志
            while(true){
                //如果链表为空
                if(temp == null){
                    System.out.print("该链表为空！");
                    break;
                }
                //如果找到需要修改的节点
                if(temp.id == heroNode.id){
                    flag = true;
                    break;
                }
                //继续进行遍历
                temp = temp.next;
            }

            //修改属性
            if(flag){
                temp.name = heroNode.name;
                temp.nickName = heroNode.nickName;
            }else { //没有找到
                System.out.printf("没有找到 编号 %d 的节点，不能修改\n", heroNode.id);
            }
        }

        //删除
        public void remove(int id){
            //因为头节点是不能动的，所以需要初始化一个辅助变量来实现遍历（类似于指针）
            HeroNode temp = head;
            boolean flag = false;//判断是否找到需要删除的节点标志
            while(true){
                //如果链表为空
                if(temp.next == null){
                    System.out.print("该链表为空！");
                    break;
                }
                //如果找到需要删除的节点
                if(temp.next.id == id){
                    flag = true;
                    break;
                }
                //继续进行遍历
                temp = temp.next;
            }
            //判断flag
            if(flag){
                temp.next = temp.next.next;
            }else {
                System.out.printf("要删除的 %d 节点不存在\n", id);
            }
        }

        //遍历链表
        public void list(){
            //判断链表是否为空
            if(head.next == null){
                System.out.print("该链表为空！");
            }
            //因为头节点是不能动的，所以需要初始化一个辅助变量来实现遍历（类似于指针）
            HeroNode temp = head.next;
            while(true){
                if(temp == null){
                    break;
                }
                //输出节点的信息
                System.out.println(temp);
                //指针后移
                temp = temp.next;
            }
        }
    }

}
Keson Z
关注
专栏目录
双向链表的增删改查
03-16
本文将详细探讨如何实现双向链表的增、删、改、查操作，并通过C++编程语言的DLink.cpp文件进行实际应用。 首先，我们需要定义双向链表的节点结构。一个双向链表节点包含两个指针，分别指向其前一个节点和后一个节点...
LinkedList底层原理
Linias的博客
02-02 407
LinkedList 首先 LinkedList 是双向列表。 链表批量增加，是靠for循环遍历原数组，依次执行插入节点操作。对比ArrayList是通过System.arraycopy完成批量增加的。增加一定会修改modCount。 通过下标获取某个node 的时候，（add select），会根据index处于前半段还是后半段 进行一个折半，以提升查询效率 删也一定...
LinkedList 的实现原理
geniushuai的专栏
02-18 1021
简单的一个类就直接说了。LinkedList 的底层结构是一个带头/尾指针的双向链表，可以快速的对头/尾节点 进行操作，它允许插 入所有元素，包括 null。 相比数组（这里可以对比ArrayList源码分析进行查看），链表的特点就是在指定位置插入和删除元素的效率较高，但是查找的 效率就不如数组那么高了。如果熟悉双向链表这个数据结构，其实就很简单了，无非就是实现一些数据的添加，删除，查询，遍历等功能，双向链表的结构图如下： 每一个数据（节点）都包含3个部分，一个是数据本身item，一个是指..
LinkedList的原理介绍
weixin_43102784的博客
01-21 435
一、LinkedList的概述 LinkedList是双向链表实现的List LinkedList是非线程安全的 LinkedList元素允许为null，允许重复元素 LinkedList是基于链表实现的，因此插入删除效率高，查找效率低（虽然有一个加速动作） LinkedList是基于链表实现的，因此不存在容量不足的问题，所以没有扩容的方法 LinkedList还实现了栈和队列的操作方法，因此也可以作为栈、队列和双端队列来使用 二、LinkedList的分析 LinkedList的存储结构 LinkedLi
【数据结构】LinkedList原理及实现学习总结
热门推荐
简约人生的博客
04-20 2万+
LinkedList 和 ArrayList 一样，都实现了 List 接口，但其内部的数据结构有本质的不同。LinkedList 是基于链表实现的（通过名字也能区分开来），所以它的插入和删除操作比 ArrayList 更加高效。但也是由于其为基于链表的，所以随机访问的效率要比 ArrayList 差。二、ListedList类定义public class Lin
集合框架及ArrayList、LinkedList源码的个人理解
lmz的博客
08-06 685
萌新对其集合框架及ArrayList、LinkedList源码的个人理解
linked-list:C用于单链表和双链表
05-12
linked-list C for single linked list and double linked list single_list 结点结构体 创建结点 创建链表 显示链表的数据 获取链表长度 插入结点 删除结点 查找链表中指定的数据 修改链表中指定位置结点的值 修改...
C语言实例-双向链表增删改查
最新发布
09-11
双向链表（Doubly Linked List）是计算机科学中的一种基本数据结构，它在单链表的基础上扩展了数据节点的指针结构。与单链表仅包含一个指向下一个节点的指针不同，双向链表的每个节点包含两个指针：一个指向前一个...
单链表（Linked-List）
11-28
单链表由一系列节点组成，每个节点包含两个部分：数据元素和指向下一个节点的指针。这种数据结构与数组不同，因为它不连续存储数据，而是通过链接来组织元素。 ### 1. 链表的概念 链表是一种线性数据结构，其中的...
不带头节点的单链表倒置算法
10-08
ListNode* head = createLinkedList(); // 自行实现创建链表的函数 ListNode* reversedHead = reverseList(head); // 打印倒置后的链表... printLinkedList(reversedHead); // 自行实现打印链表的函数 return ...
LinkedList底层原理及分析
aj15201426893的博客
11-19 1430
LinkedList底层的实现基于双向表。 prev data next next指向下一个node的地址。Prev指向上一个node。 （1） .LinkedList可以进行所有与List的操作，因为其实现了List接口，同时LinkedList可以存放任何元素，包括null; （2）、所有根据索引的查找操作都是按照双向链表的需要执行的，根据索引从前或从后开始搜索，并且从最靠近索引的一端开...
Java中LinkedList原理解析
欢迎关注微信公众号：DroidMind
03-27 1678
一句话概括，Java中的LinkedList其实就是使用了一个双向链表 上面可以清晰的看出，链表中每个元素对应一个节点，节点里面包含三部分，一个是前一个节点的引用，一个是元素内容，一个是后一个节点的引用。 向链表中添加元素的过程就是在链表尾部追加一个节点 void linkLast(E e) { final Node l = last;
LinkedList底层原理实现
qq_40264239的博客
03-26 8076
LinkedList底层原理实现 1.底层 1.LinkedList的底层是通过链表来实现的。 2.链表的单元 链表的单元是节点（Node） 链表是由多个节点构成，每个节点都包含三个部分，头部指向上一个节点，中部指向该节点，尾部指向下一个节点 双向链表： 2.优缺点 缺点：添加慢，因为需要遍历找到到最后一个指向为null的节点 优点：插入和删除快 因为可以直接改变下一个节点的指向 3.源码实现（单...
集合——LinkedList实现原理分析
FareBoy的博客
06-18 1457
 LinkedList实现原理        ArrayList和linkedList都是实现了List接口的，使用方法上也没有什么区别，但是底层所采用的数据结构是完全不一样。我们都知道ArrayList的是基于数组实现的，那LinkedList呢？        顾名思义，LinkedList底层所采用的数据结构是链表。了解数据结构的朋友都应该知道，链表是由多个节点构成，每个节点都包含三个部分，...
LinkedList的实现原理与总结
huang211630的专栏
05-11 2472
1. LinkedList概述        LinkedList是List的实现类，他是一个基于链表实现的List类，对于顺序访问集合中的元素进行了优化。特别是插入，删除元素的速度特比快。LinkedList即实现了List接口，也实现了Deque接口。因此可以作为栈来使用。        Deque接口是Queue接口的子接口，它代表一个双端队列。因此可以从两端来操作队列的元素。
LinkedList实现原理
JAVA技术爱好者
11-28 629
LinkedList实现原理LinkedListLinkedList源码分析基本属性构造方法addAll方法AddAdd指定位置添加GETSET通过指定位置迭代删除元素1.AbstractSequentialList的remove2.Deque 中的Remove双端链表（队列Queue） LinkedList LinkedList都是List下面的集合子类，LinkedList中和ArrayList在实现上有很大的区别，ArrayList是维护了一个Object的数组，而LinkedList在实现上维护了一
LinkedList原理
aobu2268的博客
06-21 137
LinkedList 实现了List接口和Deque接口 是一个先进先出 双向链表结构 重点是first 和 last 看下元素类型 Node 有next prev 和 item（current） 实现链表 1 private static class Node<E> { 2 E item; 3 Node<E&gt...
LinkedList的实现原理浅析
weixin_33862041的博客
09-17 264
2019独角兽企业重金招聘Python工程师标准>>> ...
单链表的增删改查c
06-01
好的，以下是单链表的增删改查的 C 语言实现： ```c #include #include struct Node { int data; struct Node *next; }; // 创建单链表 struct Node* createLinkedList() { struct Node *head = (struct ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Keson Z

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值