【数据结构基础】线性表 - 链表

数据结构基础讲解(三)——线性表之循环链表专项练习 线性表是一种最基本、最常用的数据结构,它是一种线性结构,数据元素之间存在着**一对一**的线性关系。学习线性表,可以帮助我们理解数据结构的基本概念,并为学习其他更复杂的数据结构打下基础。 阅读详情
n个节点离散分配,彼此通过指针相连,每个节点只有一个前驱节点,每个节点只有一个后续节点,首节点没有前驱节点,尾节点没有后续节点。确定一个链表我们只需要头指针,通过头指针就可以把整个链表都能推出来。

知识点

优缺点

链表优点

  • 空间没有限制

  • 插入删除元素很快

链表缺点 存取速度很慢

分类

  • 单向链表 一个节点指向下一个节点。

  • 双向链表 一个节点有两个指针域。

  • 循环链表 能通过任何一个节点找到其他所有的节点,将两种(双向/单向)链表的最后一个结点指向第一个结点从而实现循环。

实现

节点

public class Node {
    //数据域
    public int data;
    //指针域,指向下一个节点
    public Node next;

    public Node() {
    }
    public Node(int data) {
        this.data = data;
    }
    public Node(int data, Node next) {
        this.data = data;
        this.next = next;
    }
}

如上,一个链表节点对象就创建完成了,但理解链表本身并不难,但做相关的操作却并非易事,其算法包括且不限于:

  • 插入节点

  • 遍历

  • 查找

  • 清空

  • 销毁

  • 求长度

  • 排序

  • 删除节点

  • 去重

链表相关题目

链表是空节点,或者有一个值和一个指向下一个链表的指针,因此很多链表问题可以用递归来处理。

找出两个链表的交点

160. Intersection of Two Linked Lists (Easy)

A:          a1 → a2
                    ↘
                      c1 → c2 → c3
                    ↗
B:    b1 → b2 → b3

要求: 时间复杂度为 O(N),空间复杂度为 O(1)

设 A 的长度为 a + c,B 的长度为 b + c,其中 c 为尾部公共部分长度,可知 a + c + b = b + c + a。

当访问 A 链表的指针访问到链表尾部时,令它从链表 B 的头部开始访问链表 B;同样地,当访问 B 链表的指针访问到链表尾部时,令它从链表 A 的头部开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    ListNode l1 = headA, l2 = headB;
    while (l1 != l2) {
        l1 = (l1 == null) ? headB : l1.next;
        l2 = (l2 == null) ? headA : l2.next;
    }
    return l1;
}

如果只是判断是否存在交点,那么就是另一个问题,即 编程之美 3.6 的问题。有两种解法:

  • 把第一个链表的结尾连接到第二个链表的开头,看第二个链表是否存在环;

  • 或者直接比较两个链表的最后一个节点是否相同。

链表反转

206. Reverse Linked List (Easy)

递归

public ListNode reverseList(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    ListNode next = head.next;
    ListNode newHead = reverseList(next);
    next.next = head;
    head.next = null;
    return newHead;
}

头插法

public ListNode reverseList(ListNode head) {
    ListNode newHead = new ListNode(-1);
    while (head != null) {
        ListNode next = head.next;
        head.next = newHead.next;
        newHead.next = head;
        head = next;
    }
    return newHead.next;
}

归并两个有序的链表

21. Merge Two Sorted Lists (Easy)

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    if (l1 == null) return l2;
    if (l2 == null) return l1;
    if (l1.val < l2.val) {
        l1.next = mergeTwoLists(l1.next, l2);
        return l1;
    } else {
        l2.next = mergeTwoLists(l1, l2.next);
        return l2;
    }
}

从有序链表中删除重复节点

83. Remove Duplicates from Sorted List (Easy)

Given 1->1->2, return 1->2.
Given 1->1->2->3->3, return 1->2->3.
public ListNode deleteDuplicates(ListNode head) {
    if (head == null || head.next == null) return head;
    head.next = deleteDuplicates(head.next);
    return head.val == head.next.val ? head.next : head;
}

删除链表的倒数第 n 个节点

19. Remove Nth Node From End of List (Medium)

Given linked list: 1->2->3->4->5, and n = 2.
After removing the second node from the end, the linked list becomes 1->2->3->5.
public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode fast = head;
    while (n-- > 0) {
        fast = fast.next;
    }
    if (fast == null) return head.next;
    ListNode slow = head;
    while (fast.next != null) {
        fast = fast.next;
        slow = slow.next;
    }
    slow.next = slow.next.next;
    return head;
}

交换链表中的相邻结点

24. Swap Nodes in Pairs (Medium)

Given 1->2->3->4, you should return the list as 2->1->4->3.

题目要求: 不能修改结点的 val 值,O(1) 空间复杂度。

public ListNode swapPairs(ListNode head) {
    ListNode node = new ListNode(-1);
    node.next = head;
    ListNode pre = node;
    while (pre.next != null && pre.next.next != null) {
        ListNode l1 = pre.next, l2 = pre.next.next;
        ListNode next = l2.next;
        l1.next = next;
        l2.next = l1;
        pre.next = l2;

        pre = l1;
    }
    return node.next;
}

链表求和

445. Add Two Numbers II (Medium)

Input: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 8 -> 0 -> 7

题目要求: 不能修改原始链表。

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    Stack<Integer> l1Stack = buildStack(l1);
    Stack<Integer> l2Stack = buildStack(l2);
    ListNode head = new ListNode(-1);
    int carry = 0;
    while (!l1Stack.isEmpty() || !l2Stack.isEmpty() || carry != 0) {
        int x = l1Stack.isEmpty() ? 0 : l1Stack.pop();
        int y = l2Stack.isEmpty() ? 0 : l2Stack.pop();
        int sum = x + y + carry;
        ListNode node = new ListNode(sum % 10);
        node.next = head.next;
        head.next = node;
        carry = sum / 10;
    }
    return head.next;
}

private Stack<Integer> buildStack(ListNode l) {
    Stack<Integer> stack = new Stack<>();
    while (l != null) {
        stack.push(l.val);
        l = l.next;
    }
    return stack;
}

回文链表

234. Palindrome Linked List (Easy)

题目要求: 以 O(1) 的空间复杂度来求解。

切成两半,把后半段反转,然后比较两半是否相等。

public boolean isPalindrome(ListNode head) {
    if (head == null || head.next == null) return true;
    ListNode slow = head, fast = head.next;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    if (fast != null) slow = slow.next;  // 偶数节点,让 slow 指向下一个节点
    cut(head, slow);                     // 切成两个链表
    return isEqual(head, reverse(slow));
}

private void cut(ListNode head, ListNode cutNode) {
    while (head.next != cutNode) {
        head = head.next;
    }
    head.next = null;
}

private ListNode reverse(ListNode head) {
    ListNode newHead = null;
    while (head != null) {
        ListNode nextNode = head.next;
        head.next = newHead;
        newHead = head;
        head = nextNode;
    }
    return newHead;
}

private boolean isEqual(ListNode l1, ListNode l2) {
    while (l1 != null && l2 != null) {
        if (l1.val != l2.val) return false;
        l1 = l1.next;
        l2 = l2.next;
    }
    return true;
}

分隔链表

725. Split Linked List in Parts(Medium)

Input:
root = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], k = 3
Output: [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
Explanation:
The input has been split into consecutive parts with size difference at most 1, and earlier parts are a larger size than the later parts.

题目描述: 把链表分隔成 k 部分,每部分的长度都应该尽可能相同,排在前面的长度应该大于等于后面的。

public ListNode[] splitListToParts(ListNode root, int k) {
    int N = 0;
    ListNode cur = root;
    while (cur != null) {
        N++;
        cur = cur.next;
    }
    int mod = N % k;
    int size = N / k;
    ListNode[] ret = new ListNode[k];
    cur = root;
    for (int i = 0; cur != null && i < k; i++) {
        ret[i] = cur;
        int curSize = size + (mod-- > 0 ? 1 : 0);
        for (int j = 0; j < curSize - 1; j++) {
            cur = cur.next;
        }
        ListNode next = cur.next;
        cur.next = null;
        cur = next;
    }
    return ret;
}

链表元素按奇偶聚集

328. Odd Even Linked List (Medium)

Example:
Given 1->2->3->4->5->NULL,
return 1->3->5->2->4->NULL.
public ListNode oddEvenList(ListNode head) {
    if (head == null) {
        return head;
    }
    ListNode odd = head, even = head.next, evenHead = even;
    while (even != null && even.next != null) {
        odd.next = odd.next.next;
        odd = odd.next;
        even.next = even.next.next;
        even = even.next;
    }
    odd.next = evenHead;
    return head;
}
数据结构基础讲解(二)——线性表之单链表专项练习 线性表链式存储结构的特点是:用一 组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的,也可以是不连续的)。因此,为了表示每个数据元素ai与其直接后继数据元素ai+1之间的逻辑关系,对数据元素ai来说,除了存储其本身的信息之外,还需存储一个指示其直接后继的信息(即直接后继的存储位置)。这两部分信息组成数据元素ai的存储映像,称为结点。它包括两个域:其中存储数据元素信息的域称为数据域;存储直接后继存储位置的域称为指针域。指针域中存储的信息称作指针或链。 阅读详情

相关推荐

线性表与链表:数据结构基础与工程实践

数据结构是计算机科学的核心基础,其中线性表作为最基本的数据组织形式,通过顺序表(数组)和链表两种物理实现方式支撑着各类算法与应用。顺序表利用连续内存空间实现O(1)随机访问,适合高频查询场景;而链表通过指针动态连接节点,在频繁增删操作中表现优异。理解二者的底层原理与性能差异,对开发高性能系统至关重要。在实际工程中,如高频交易系统采用顺序表优化缓存命中,文本编辑器使用链表实现高效编辑,这种基于场景的选型能力是资深工程师的关键技能。本文结合内存布局、时间复杂度分析和真实案例,深入解析这两种基础结构的工程实践与优

weixin_30824599的博客 838

JAVA基础-数据结构一(线性表、链表、栈、队列)

/定义一个泛型数组//数组内元素的实际数量//size代表数组里实际有效的数据数量java里面没有像C语言的结构体,但java有内部类新建一个内部类Node表示链表内的单个节点,内部类中包括1.元素2.指向下一节点的指针3.构造函数给元素赋值构造好节点类,再新建头结点和尾结点指针,并新建size表示链表的有效长度{//定义一个结点内部类E data;Node next;//指向下一结点的指针//头结点//尾结点//链表实际长度。

2302_76949164的博客 1369

数据结构基础知识概念 数据结构的逻辑结构: 线性表 顺序表 链表 栈和队列 栈的链式存储: 队列的链式存储:

目录 数据结构是什么? 数据结构的存储结构: 线性表 树存储结构 图存储结构 一、基本概念 2、算法的基本概念 二、线性表 三、栈和队列 四、树、二叉树 五、图 六、查找 七、排序 数据结构是什么? 我认为,数据结构是一门学科,它教会我们“如何存储具有复杂关系的数据更有助于后期对数据的再利用”。 数据结构的存储结构: 线性表,还可细分为顺序表、链表、栈和队列; 树结构,包括普通树,二叉树,线索二叉树等; 图存储结构; 线性表 线性表结构...

ZhangJiqun&191cm&85kg 667

《数据结构基础知识①》--概念+线性表+单链表

截图来自王卓老师的视频:数据结构与算法基础(青岛大学-王卓)_哔哩哔哩_bilibili 【持续更新....】 目录 一、基本概念 1.数据(Data) 2.数据元素(Data element) 3.数据项 4.数据对象(Data Object) 5.数据结构(Data Structure) 6.数据结构的两个层次(逻辑/物理结构) 7.逻辑结构的种类 8.存储结构的种类 9.数据类型(Data Type) 10.抽象数据类型(Abstract Data Type,ADT ).

yyldeh的博客 1408

如何在RT-DETR-R18中修改ultralytics的yaml文件(附完整代码)

本文详细指导如何在RT-DETR模型中,通过修改Ultralytics框架的yaml配置文件,将Backbone从ResNet50轻量化替换为ResNet18。核心步骤包括自定义ResNet18基础模块、调整HybridEncoder的expansion参数至0.5,并协同修改检测头Decoder层数,最终提供完整的配置文件代码,助力开发者在资源受限环境下部署轻量级实时目标检测模型。

weixin_29091445的博客 290

学好超几何分布的核心公式,破解双色球!

彩票本质是概率游戏,不存在"必中公式"科学投注的核心是风险收益比管理长期投注的期望值始终为负(理论回报率约47%-63%)数学维度:运用概率工具优化策略经济维度:控制投注成本在可承受范围人文维度:将彩票视为社会公益的参与方式通过本文构建的数学模型,彩民可以在概率框架内实现更理性的投注决策。但最终能否收获幸运,仍取决于那个永恒的未知数——概率女神的眷顾。一、超几何分布的核心公式。

weixin_44904675的博客 1万+

(数据结构)基础概念,时间复杂度,线性表,链表,栈

广义: 如何把数据高效储存在计算机的内存中,方便后续使用(增,删,改,查)。数据量本身还比较大。定义: 相互之间存在一种或多种特定关系的数据元素的集合。逻辑结构: 从人的思维角度去分析数据与数据的关系1.集合,2 线性, 1对1, 排队3 树, 1对多 目录结构4 图, 多对多 , 地图,网络结构物理结构:把逻辑结构按照某种方式存储计算机的内存中1.线性存储 ,在内存连续存储,数据存放在连续的存储单位中。逻辑关系和物理关系一致。

weixin_62813293的博客 674

WPS中VBA支持库安装全攻略:从报错到一键解决

VBA作为Office生态中广泛使用的宏语言,是办公自动化的重要基础。WPS表格虽然兼容Excel文件格式,但出于技术路线与授权原因,默认并未集成完整的VBA引擎与开发环境,导致用户打开含宏文件时频繁遇到“找不到工程或库”“未找到VBA支持库”等报错。理解VBA支持库包含引擎与IDE两层结构,并掌握系统位数、版本匹配、安全软件拦截等前置条件,是成功部署的关键。通过可靠的安装源与规范流程完成配置后,即可实现在WPS中运行Excel宏、批量处理数据、自定义函数等自动化场景,显著提升报表处理效率。本文围绕WPS中

weixin_31102231的博客 318

数据结构基础:线性表与链表详解

1.线性表是最基本、最简单、也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列。•前驱元素:若A元素在B元素的前面,则称A为B的前驱元素。•后继元素:若B元素在A元素的后面,则称B为A的后继元素。2.线性表的特征:①. 第一个数据元素没有前驱,这个数据元素被称为头结点;②. 最后一个数据元素没有后继,这个数据元素被称为尾结点;③. 除了第一个和最后一个数据元素外,其他数据元素有且仅有一个前驱和一个后继。3.分类:线性表中数据存储的方式可以是,也可以是。

RT__Wang的博客 1112

C# OpenCvSharp4实战:5分钟搞定工业视觉模板匹配(附完整代码)

本文为C#开发者提供了基于OpenCvSharp4的工业视觉模板匹配实战指南。通过详细的环境搭建、核心原理解析和完整代码示例,重点介绍了如何使用`matchTemplate`函数,特别是`CCoeffNormed`方法,快速实现高精度、抗光照变化的模板匹配,并分享了多目标匹配、图像预处理等工业级优化技巧。

weixin_29053067的博客 507

CDR插件开发之CPG插件004 - 认识VGCore并编译生成你的第一个CPG文件

上篇文章中,讲到了使用VS2019编译CDR类型库 VGCoreAuto.tlb,编译后得到了vgcoreauto.tlh和vgcoreauto.tli两个文件。本文将对这两个文件说明,并演示通过标准的libid形式来导入CDR类型库,在这个过程中,穿插一些VS2019的使用技巧(删除目录、复制工程、打开项目或解决方案、修改解决方案名称、修改项目名称等),使读者循序渐进,逐步提高对VS2019工具的熟练程度,最后通过修改项目属性配置,生成第一个CPG文件。

Zebe 2989

Java数据结构基础——实现线性表和链表

1. 引言 2. 线性表的通用特性 2.1 MyList接口 2.2 MyAbstractList抽象类 3. 数组线性表 3.1 MyArrayList实现类 3.2 MyArrayList测试类 1. 引言 通过接口MyList定义通用功能,抽象类MyAbstractList实现部分功能,MyArrayList和MyLinkedList实现类的方式进一步理解...

Littlemotor 1018

用 OP-TEE 给 AI 模型“上锁”:密文存储、TEE 解密放行、推理后销毁(实战可落地)

本文提出一种基于OP-TEE的AI模型保护方案,通过两级密钥体系确保模型静态存储为密文,运行时仅在TEE内解密。方案采用KEK+DEK架构,DEK永不出TEE,支持分块解密与可验证擦除。该方案能有效防御静态分析、应用层逆向等威胁,但需承认其物理级攻击的局限性。文章详细描述了端到端架构、文件格式设计及TA实现要点,包括密钥管理、分块解密策略和销毁机制,为设备侧AI部署提供了工程可行的安全解决方案。

Interview_TC的博客 294

夯实基础:数据结构核心概念与线性表(顺序表&链表)C语言全解析 数据结构篇

本文摘要:文章系统介绍了数据结构中的逻辑结构(线性、树形、图形)和存储结构(顺序、链式、索引、散列),重点讲解了顺序表和链表的实现。顺序表采用数组实现,具有随机访问特性;链表分为单向、双向和循环链表,详细阐述了头插法、尾插法、查找、删除和替换等基本操作。通过C语言代码示例展示了顺序表的动态内存管理和链表节点的操作实现,包括创建、销毁、插入、遍历等核心功能,为数据结构的学习提供了实践参考。

2302_80623234的博客 676

36、T5L 迪文屏C51开发之绘制动态曲线

T5L 迪文屏C51开发之绘制动态曲线1、介绍2、例程功能简介3、GUI界面设计3、C51程序设计 1、介绍   本文将利用DGUS Tool软件中的【动态曲线控件】来绘制曲线效果,在T5L迪文屏中总共支持8个通道的曲线,而曲线数据是需要缓冲区的,如果 8 通道曲线同时使用,0x1000-0x4FFF 将作为曲线缓冲区地址,此时该部分变量地址不能被其他控键使用,其他控键地址使用范围为0x5000-0xFFFF,当某曲线通道不被使用时,那么其所对应的缓冲区地址可以做其他用途,曲线通道具体的地址分布如下图所示:

嵌入式羊圈 3135

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

数据结构~基础1~线性表【《数组、链表、栈、队列》的设计】

/添加【双向链表】——【分类:添加到最后位置时(这里还要考虑空链表的情况), 其他位置(还要考虑到添加到第一个位置时)】if (prev == null) { // index == 0【添加到第一个位置】if (oldLast == null) { // 这是链表添加的第一个元素。//删除【双向链表】——【分类:删除最后位置和删除第一个位置】//删除结点头结点情况--也要分类,只是分类完可以同一处理】//添加【头结点情况--也要分类,只是分类完可以同一处理】【顺序存储,元素地址是连续的】

m0_66468899的博客 54

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

【数据结构基础笔记】第二章线性表之单链表

目录 一、简要 1、涵盖内容 2、学习要求 二、导入 三、线性链表 1、链式存储结构 2、注意点 四、单链表 1、单链表优点 2、单链表缺点 3、结点类型描述 4、注意点 五、单链表的实现 1、链表的创立 2、链表的操作 3、代码应用 一、简要 好久没有写基础笔记了,当时为了写基础笔记是为了能重新巩固数据结构,后来因为考研,就改成了数据结构周周练,但是很多同学看...

水亦心的博客 3727

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

Algorithms_基础数据结构(02)_线性表之链表_单向链表

链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的

小工匠 2万+

【编程与算法基础】数据结构——线性表之双链表

线性表(linear list)是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构,常见的线性表:顺序表、链表、栈、队列等。线性表在逻辑上是线性结构,也就说是连续的一条直线。但是在物理结构上并不一定是连续的,线性表在物理上存储时,通常以数组和链式结构的形式存储。链表是典型的线性表之一,以链式结构的形式存储。链表又被分为单链表和双链表。本片仅对双链表详细说明。

qq_52158753的博客 477

数据结构之线性表01(顺序表、单链表、静态链表 基础)

线性表是数据结构的一种,线性表中数据元素之间的关系是一对一的关系。除了第一个元素和最后一个元素之外,每一个元素有且只有一个前驱和一个后继,第一个元素没有前驱,最后一个元素没有后继。 线性表可以分为顺序存储和链式存储。 顺序存储:顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素,称为线性表的顺序存储结构或顺序映像。 链式存储:用一组任意的存储单元存储线性表中的数据元素,称为线性表的链...

xiaozhao 360

数据结构基础(三)——线性表之单链表

上篇文章介绍了线性表的顺序储存结构(顺序表),这篇文章接着介绍链表的相关内容。 一、单链表的定义和表示 单链表:线性表链式存储结构,用于存储逻辑关系为 “一对一” 的数据。与顺序表不同,链表不限制数据的物理存储状态,换句话说,使用链表存储的数据元素,其物理存储位置是随机的。 单链表的特点:用一组任意的存储单元存储线性表的数据元素。 例如,使用链表存储 {1,2,3},数据的物理存储状态如图所示 ...

qq_45836560的博客 3013

【编程与算法基础】数据结构——线性表之单链表

线性表(linear list)是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构,常见的线性表:顺序表、链表、栈、队列等。线性表在逻辑上是线性结构,也就说是连续的一条直线。但是在物理结构上并不一定是连续的,线性表在物理上存储时,通常以数组和链式结构的形式存储。链表是典型的线性表之一,以链式结构的形式存储。链表又被分为单链表和双链表。本片仅对单链表详细说明。

qq_52158753的博客 498

C语言数据结构(二),基础的线性表,单链表

此处为c语言数据结构,严蔚敏那一版本的学习笔记。以下为个人庸俗理解,不准确。 串的模式匹配算法: 1.逐个字符对比。算法的时间复杂度O(n*m),某些时候趋近O(n+m),这里的某些时候,很重要。 2.KMP算法。时间复杂度O(n+m),不用指针回溯。处理外设输入的庞大文件很有效果,边读入遍匹配。 注意: 以下代码为书中例程,稍作修改了一下,我自己没有真正编译并使用过,仅供参考,不保证能使用 //...

506
上一篇: 【数据结构基础】线性表 - 数组和矩阵
下一篇: 【数据结构基础】线性表(散列)- 哈希表
毕设王同学
博客等级 码龄12年 133粉丝 128原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

毕设王同学

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

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

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

打赏作者

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

抵扣说明:

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

余额充值