【考研】线性表的应用之有序表的合并

已于 2022-10-30 16:38:30 修改
阅读量4.1k 收藏 91
点赞数 2
分类专栏： 数据结构 考研 C++ 文章标签： 数据结构 算法 学习
于 2022-08-26 17:14:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34438969/article/details/126544665
版权
考研 同时被 3 个专栏收录
70 篇文章 85 订阅
订阅专栏
数据结构
34 篇文章 55 订阅
订阅专栏
C++
21 篇文章 1 订阅
订阅专栏

前言

本文内容源于对《数据结构（C语言版）》（第2版）、王道讲解学习所得心得、笔记整理和总结。

1、有序表（Order List）：数据元素相互之间可以比较，且数据元素在线性表中依值非递减或非递增有序排列。

2、有序集合：集合中的元素有序排列。

求解有序集合的并集问题，考点为有序表的合并，其又可分为顺序有序表的合并、链式有序表的合并。本文以举例子说明此两种合并，部分题目内含多种解法，讲解详细。

其中，顺序有序表的合并，类似于归并排序算法，所以，可搭配以下链接进行学习：

【考研】数据结构考点——归并排序_住在阳光的心里的博客-CSDN博客

【考研】《数据结构》知识点总结.pdf_考研数据结构知识点总结背诵-其它文档类资源-CSDN文库

目录

前言

一、有序表的合并

（一）顺序有序表的合并

1、算法步骤

2、算法代码

3、算法分析

（二）链式有序表的合并 

1、算法步骤

2、算法代码

3、算法分析

二、练习

（一）解法一：暴力解（数组保存 + 快速排序）

1、算法思想

2、算法分析

3、算法代码

（二）解法二：较优解（数组保存 + 指针后移归并）

1、算法思想

2、算法分析

3、算法代码

（三）解法三：最优解（指针后移归并 + 头插法逆置）

1、算法思想

2、算法分析

3、算法代码

一、有序表的合并

已知两个有序集合 A = （3，5，8，11），B = （2，6，8，9，11，15，20），数据元素按值非递减有序排列，现要求一个新的集合 C=A\cup B，使集合 C 中的数据元素仍按值非递减有序排列。

解析：记三个线性表 LA、LB 和 LC分别表示集合 A 、B 和 C，其表长分别为 m 、n 和 m + n 。

可先假设 LC 为空表，再将 LA 或 LB 中的元素逐个插入 LC 中。

因为 LC 是按值非递减有序排列，所以可设两个指针 pa 和 pb 分别指向 LA、LB 中的某个元素，若设 pa 、pb 当前所指元素分别为 a 、b，则当前应插入到 LC 中的元素 c 为 c=\left\{\begin{matrix} a & ,a\leq b \\ b & ,a> b \end{matrix}\right.，显然，指针 pa 和 pb 分别指向两个有序表的第一个元素，在所指元素插入 LC 之后，在  LA 或 LB 中顺序后移。

以下是有序表的顺序存储结构和链式存储结构相应合并算法的实现。

（一）顺序有序表的合并

1、算法步骤

1、创建一个表长为 m + n 的空表 LC。

2、指针 pc 初始化，指向 LC 的第一个元素。

3、指针 pa 和 pb 初始化，分别指向 LA 和 LB 的第一个元素。

4、当指针 pa 和 pb 均未到达相应表尾时，则依次比较 pa 和 pb 所指向的元素值，从 LA 或 LB 中“摘取” 元素值较小的结点插入到 LC 的最后。

5、如果 pb 已到达 LB 的表尾，依次将 LA 的剩余元素插入 LC 的最后。

6、如果 pa 已到达 LA 的表尾，依次将 LB 的剩余元素插入 LC 的最后。
 

2、算法代码

//顺序表的存储结构
typedef struct{
    ElemType *elem;
    int length;
}SqList;

//已知顺序有序表 LA 和 LB 的元素按值非递减排列
//归并 LA 和 LB 得到新的顺序有序表 LC, LC 的元素也按值非递减排列
void MergeList_Sq (SqList LA, SqList LB, SqList &LC){
    int m = LA.length, n = LB. length;
    LC.length = m + n;      //新表长度为待合并两表的长度之和

    LC.elem = new ElemType[LC.length];      //为合并后的新表分配一个数组空间
    pc = LC.elem;     //指针 pc 指向新表的第1个元素

    //指针 pa 和 pb 的初值分别指向两个表的第1个元素
    pa = LA.elem;
    pb = LB.elem;

    pa_last = LA.elem + m - 1;    //指针 pa_last 指向 LA 的最后一个元素
    pb_last = LB.elem + n - l;    //指针 pb_last 指向 LB 的最后一个元素

    while((pa <= pa_last) && (pb <= pb_last)){     // LA 和 LB 均未到达表尾
        if(*pa <= *pb) *pc++ = *pa++;     //依次“摘取”两表中值较小的结点插入到 LC 的最后
        else *pc++ = *pb++;
    }

    while(pa <= pa_last) *pc++ = *pa++;    //LB已到达表尾，依次将 LA 的剩余元素插入 LC 的最后
    while(pb <= pb_last) *pc++ = *pb++;    //LA已到达表尾，依次将 LB 的剩余元素插入 LC 的最后
}

3、算法分析

（1）时间复杂度：O(m + n)

（2）空间复杂度：O(m + n)

【补充：合并线性表的完整代码，看下方】

//C语言
#include<stdio.h>
#include<stdlib.h>

#define MaxSize 10

//顺序表的存储结构
typedef struct{
    int *elem;
    int length;
}SqList;
 
//已知顺序有序表 LA 和 LB 的元素按值非递减排列
//归并 LA 和 LB 得到新的顺序有序表 LC, LC 的元素也按值非递减排列
void MergeList_Sq(SqList LA, SqList LB, SqList *LC){
    int m = LA.length, n = LB.length;
    LC->length = m + n;      //新表长度为待合并两表的长度之和
 
    LC->elem = (int*)malloc(MaxSize * sizeof(int));     //为合并后的新表分配一个数组空间
    int *pc = LC->elem;     //指针 pc 指向新表的第1个元素
 
    //指针 pa 和 pb 的初值分别指向两个表的第1个元素
    int *pa = LA.elem;
    int *pb = LB.elem;
 
    int *pa_last = LA.elem + m - 1;    //指针 pa_last 指向 LA 的最后一个元素
    int *pb_last = LB.elem + n - 1;    //指针 pb_last 指向 LB 的最后一个元素
 
    while((pa <= pa_last) && (pb <= pb_last)){     // LA 和 LB 均未到达表尾
        if(*pa <= *pb) *pc++ = *pa++;     //依次“摘取”两表中值较小的结点插入到 LC 的最后
        else *pc++ = *pb++;
    }
 
    while(pa <= pa_last) *pc++ = *pa++;    //LB已到达表尾，依次将 LA 的剩余元素插入 LC 的最后
    while(pb <= pb_last) *pc++ = *pb++;    //LA已到达表尾，依次将 LB 的剩余元素插入 LC 的最后
}

//创建顺序表
void initList(SqList* L){
    L->elem = (int*)malloc(MaxSize * sizeof(int));    //构造一个空的顺序表，动态申请存储空间
    
    if (!L->elem){
        printf("初始化失败");
        exit(0);
    }
    L->length = 0;   //空表的长度初始化为0
}

//插入函数，其中，e为插入的元素，i为插入到顺序表的位置
void insertList(SqList* L, int i, int e){
    if ((i > L->length + 1) || (i < 1)) {   //i值不合法
        printf("插入位置有问题\n");
        return;
    }

    if (MaxSize == L->length) {
    	printf("当前存储空间已满\n");
    	return;
    }
    //插入操作，需要将自插入位置之后的所有元素全部后移一位
    for (int j = L->length - 1; j >= i - 1; j--) {
        L->elem[j + 1] = L->elem[j];
    }
    
    L->elem[i - 1] = e;    //后移完成后，直接插入元素
    L->length++;    //表长加一
}

//输出顺序表中的元素
void displayList(SqList L){
    for (int i = 0; i < L.length; i++) {
        printf("%d ", L.elem[i]);
    }
    printf("\n");
}

int main(){
	SqList LA, LB, LC;
	
	initList(&LA);
	initList(&LB);
	initList(&LC);
	
    for (int i = 1; i <= MaxSize; i++) {
        LA.elem[i - 1] = i;
        LA.length++;
    }
    
    for (int j = 1; j <= MaxSize; j++) {
        LB.elem[j - 1] = j + 2;
        LB.length++;
    }
    
	printf("顺序表LA(元素按值非递减排列)：\n");
    displayList(LA);
    
    printf("顺序表LB(元素按值非递减排列)：\n");
    displayList(LB);
    
    printf("归并 LA 和 LB 得到新的顺序有序表 LC：\n");
	MergeList_Sq(LA, LB, &LC);
	displayList(LC);
}

运行结果如下：

 

（二）链式有序表的合并 

1、算法步骤

1、指针 pa 和 pb 初始化，分别指向 LA 和 LB 的第一个结点。

2、LC 的结点取值为 LA 的头结点。

3、指针 pc 初始化，指向 LC 的头结点。

4、当指针 pa 和 pb 均未到达相应表尾时，则依次比较 pa 和 pb 所指向的元素值，从 LA 或 LB 中“摘取”元素值较小的结点插人到LC的最后。

5、将非空表的剩余段插入到 pc 所指结点之后。

6、释放 LB 的头结点。

2、算法代码

//已知单链表 LA 和 LB 的元素按值非递减排列
//归并 LA 和 LB 得到新的单链表 LC, LC 的元素也按值非递减排列
void MergeList_L(LinkList &LA, LinkList &LB, LinkList &LC){
    //pa 和 pb 的初值分别指向两个表的第一个结点
    pa = LA->next; 
    pb = LB->next;

    LC = LA;      //用 LA 的头结点作为 LC 的头结点
    pc = LC;     //pc 的初值指向 LC 的头结点

    while (pa && pb){    //LA和LB均未到达表尾，依次“摘取”两表中值较小的结点插入到 LC 的最后
        if (pa->data <= pb->data){    //“摘取” pa 所指结点
            pc->next = pa;     //将 pa 所指结点链接到 pc 所指结点之后
            pc = pa;    //pc 指向 pa
            pa = pa->next;    //pa 指向下一结点
        }
        else{    //“摘取” pb 所指结点
            pc->next = pb;      //将 pb 所指结点链接到 pc 所指结点之后
            pc = pb;     //pc 指向 pb
            pb = pb->next;    //pb 指向下一结点
        }
    }

    pc->next = pa?pa:pb;    //将非空表的剩余段插入到 pc 所指结点之后
    delete LB;      //释放 LB 的头结点
}

3、算法分析

（1）时间复杂度：O(m + n)

（2）空间复杂度：O(1)

二、练习

有两个带头节点的降序单链表 L1、L2，较长的链表元素个数为 n。链表结点定义如下所示。请设计一个时间上尽可能高效算法，按升序输出两个链表中所有元素的权值。

typedef struct LinkNode {
    double data;      //权值
    struct LinkNode *next;      //指向单链表的下一个结点
} LinkNode, *Linklist;

（一）解法一：暴力解（数组保存 + 快速排序）

1、算法思想

将两个链表存入数组A中，通过对数组A进行快速排序，再从后到前升序输出数组。

2、算法分析

时间复杂度为 O(nlog_2n)，空间复杂度为 O(n)。

3、算法代码

void Qsort(double A[], int L, int R){    //a 数组保存数据，L 和 R 是边界
    if (L >= R) return;    //当前区间元素个数 <= 1 ，则退出
    int pivot, i = L, j = R;     //i 和 j 是左右两个数组下标移动
    swap(A[L], A[m]);      //A[m]是在 A[L~R]之间随机选取的一个元素（快排优化）
    pivot = A[L];     //pivot 作为枢值参与比较

    while (i<j){
        while (i < j && A[j] > pivot) j--;
        while (i < j && A[i] <= pivot) i++;
        if (i < j) swap(A[i], A[j]);      //交换 A[i] 和 A[j]
    }
    swap(A[L], A[i]);
    Qsort(A, L, i-1);     //递归处理左区间
    Qsort(A, i+1, R);     //递归处理右区间
}

void ans(Linklist L1, L2){
    double A[maxn];
    int t = 0;     // t 是新数组中元素个数

    Linklist p = L1->next;     //p 指向 L1 链表的第一个元素
    while (p != null){      //链表 L1 转数组保存
        A[t++] = p->data;
        p = p->next;
    }

    Linklist q = L2->next;     //q 指向 L2 链表的第一个元素
    while (q != null){     //链表 L2 转数组保存
        A[t++] = q->data；
        q = q->next;
    }

    Qsort(A, 0, t-1);
    for(int i = t - 1; i >= 0; i--){  //数组从后到前升序输出
        cout<<A[i]<<", ";
    }
}

（二）解法二：较优解（数组保存 + 指针后移归并）

1、算法思想

将两链表归并存入数组得到降序数组，然后从后到前升序输出数组。

2、算法分析

时间复杂度为 O(n)，空间复杂度为 O(n)。

3、算法代码

void ans(Linklist L1, L2){
    double A[maxn];
    int t = 0;    //t 是新数组中元素个数
    Linklist p = L1->next;   //p 指向 L1 链表的第一个元素
    Linklist q = L2->next;   //q 指向 L2 链表的第一个元素

    while (p!= null && q != null) //归并两个降序链表，每次选较大元素
    if (p->data > q->data){
        A[t++] = p->data;
        p = p->next;
    }
    else{
        A[t++]=q->data;
        q=q->next;
    }

    while (p != null){     //如果 L1 链表中有剩余元素则放在数组末尾
        A[t++] = p->data;
        p = p->next;
    }
    while (q != null){     //如果 L2 链表中有剩余元素则放在数组末尾
        A[t++] = q->data;
        q = q->next;
    }
    for (int i = t-1; i >= 0; i--)
        cout << A[i] << ",";    //数组从后到前升序输出
}

（三）解法三：最优解（指针后移归并 + 头插法逆置）

1、算法思想

将两链表归并到链表 L3 中，归并时采用头插法（输入顺序与线性表中的逻辑顺序是相反的），得到的降序链表 L3，依次输 出链表中的元素。

2、算法分析

时间复杂度为 ​​​​​​​O(n)，空间复杂度为 O(1)。

3、算法代码

typedef struct LinkNode {
    double data;      //权值
    struct LinkNode *next;      //指向单链表的下一个结点
} LinkNode, *Linklist;


LinkNode L3; //定义全局变量 L3
Linklist Head_Insert(Linklist p){    //头插法插入 L3 中
    Linklist p1 = p->next;
    p->next = L3->next;
    L3->next = p;
    p = p1;
    return p;
}

void ans(Linklist L1, L2){
    int t = 0; //t 是新数组中元素个数
    Linklist p = L1->next;    //p 指向 L1 链表的第一个元素
    Linklist q = L2->next;    //q 指向 L2 链表的第一个元素
    L3->next = null;    //初始链表 L3 为空

    while (p != null && q != null){    //归并两个降序链表，每次选较大元素
        if (p->data > q->data)
            p = Head_Insert(p);    //将 p 头插法插入 L3 中，p 指向下一个结点
        else
            q = Head_Insert(q);    //将 q 头插法插入 L3 中，q 指向下一个结点
    }

    while (p != null){    //如果 L1 链表中有剩余元素则头插法插入 L3
        p = Head_Insert(p);     //将 p 头插法插入 L3 中，p 指向下一个结点

    while (q != null)     //如果 L2 链表中有剩余元素则头插法插入 L3
        q = Head_Insert(q);     //将 q 头插法插入 L3 中，q 指向下一个结点

    p = L3->next;

    while (p != null){      //依次输出链表 L3 中的元素
        cout << p->data;
         p=p->next;
    }
}

住在阳光的心里
关注
专栏目录
1324: 算法2-2：有序线性表的有序合并
一零之间
07-24 2988
1324: 算法2-2：有序线性表的有序合并 时间限制: 1 Sec内存限制: 32 MB提交: 1582解决: 335 题目描述 已知线性表 LA 和 LB 中的数据元素按值非递减有序排列，现要求将 LA 和 LB 归并为一个新的线性表 LC， 且 LC 中的数据元素仍然按值非递减有序排列。例如，设LA=(3,5,8,11) ,LB=(2,6,8,9,11,15,20) 则 LC=(2,
[数据结构]线性表合并
weixin_34218890的博客
02-09 3943
一、问题描述 线性表合并是程序设计语言编译中的一个最基本的问题，现在有两个线性表LA和LB，其中的元素都是按照非递减有序排列的，要将两个LA和LB归并为一个新的线性表LC，使得LC中的元素仍然是非递减有序的。 本实验的合并方式有两种。第一种是分别取LA和LB的第一个元素，即各自的最小的元素进行比较，选择较小的元素加入LC尾部，然后重复以上步骤；当LA表空了或者LB表空了的时候，将另一个表剩下的...
有序线性表合并
04-05
有序线性表的合并，用C语言来描述的，是线性表的基本操作
线性表学习06——线性表、有序表的合并
最新发布
2301_80034711的博客
05-11 510
已知线性表La和Lb中的数据元素按值非递减有序排列，现要求将La和Lb归并为一个新的线性表Lc，且Lc中的数据元素仍按值非递减有序排列。④当指针pa和pb均为到达相应表尾时，则依次比较pa和pb所指向的元素值，从La或Lb中摘取元素值较小的结点插入Lc的最后。算法的时间复杂度和空间度均为O(ListLength(La)+ListLength(Lb))②依次从La或Lb中“摘取”元素值较小的结点插入到Lc表的最后，直至其中一个表变为空为止。③继续将La或Lb其中一个表的剩余结点插入在Lc表的最后。
有序表的合并
qq_44750091的博客
11-17 3740
有序表：若线性表中的数据元素相互之间可以相互比较，并且数据元素在线性表中依值非递减或非递增有序排列，则称该线性表为有序表。 有序集合：指集合中的元素有序排列 已知两个有序集合A和B，数据元素按值非递减有序排列，现要求一个新集合C = A U B，使集合C中的数据元素扔按值非递减有序排列。 算法如下： 1、顺序有序表的合并 算法思想： 1.1、创建一个长为m+n的空表LC 1.2、指针pc初始化，指向LC的第一个元素 1.3、指针pa，pb初始化，分别指向LA和LB的第一个元素 1.4、当指针pa和pb均未到
有序表合并（顺序表）
ulm23的博客
07-31 285
有序表合并（顺序表）
[总结]线性表综合应用：建立顺序表、排序、单链表、链表逆置、合并链表顺序表
weixin_42278339的博客
07-17 1313
写在前面：大家好，我是草莓橙须圆。毕业之前在CSDN和微信公众号活跃 欢迎关注我的公众号：【草莓橙须圆】 微信公众号主要就是更新大学生或者考研党的日常 CSDN主要就是学习过程中总结的笔记，以及编程分享 关于线性表，还是先看运行结果吧。 （1）按照输入的顺序建立顺序表： 线性表采用顺序存储的方式存储就称之为顺序表，顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 线性表的动态分配顺序结构： typedef struct{//顺序表的存储结构定义 DataType data[L.
【计算机考研·数据结构】线性表的顺序表示·程序设计题
CCH²¹的博客
03-15 1242
题目出处：王道考研2022年数据结构考研复习指导 1.从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删函数的值。空出的位置由最后一个元素填补，若顺序表为空，则显示出错信息并退出运行。 遍历顺序表，记录最小值元素及其位置，遍历结束后用最后一个元素填补到记录的位置，顺序表长度减1。 bool del_min(SqList& L, ElemType& value) { if (L.length == 0) { // 显示出错信息 retu.
合并两个有序顺序表
04-01
合并两个有序的顺序表，使用语言是C++，数据结构里的一个基础的算法。
考研——线性表算法大题整理(二)
Jayna_Su的博客
10-05 292
整理了来自《天勤》《王道》的例题+课后习题
王道数据结构考研课后习题（线性表）
2201_75825034的博客
08-26 251
int* data;int length;}SeqList;int pos;L.length--;return 0;
两个有序表的合并（三种方法）
热门推荐
兔子王
09-29 1万+
设有两个递增排列的有序表，要求合并后仍按递增（非递减）有序排列
Java-合并有序链表
luzhensmart的专栏
10-02 190
题目描述 将两个有序的链表合并为一个新链表，要求新的链表是通过拼接两个链表的节点来生成的。 1->2->3 2->3->4->5 合并结果: 1->2->2->3 >3 >4->5 import java.util.*; /* * public class ListNode { * int val; * ListNode next = null; * } */ public class Solutio.
有序顺序表的合并
yy_1121的博客
03-12 807
有序顺序表的合并
链式有序表的合并
晔晔的博客
09-21 1055
又接着看了链式有序表的合并๑乛◡乛๑ head.h头文件——包含了 各种声明还有结构体定义 #ifndef HEAD_H_INCLUDED #define HEAD_H_INCLUDED #define ElemType int #define Status int typedef struct Node { ElemType data; struct Node *next
用单链表表示集合，集合中的元素递增有序，设计算法求两个集合的并集。要求不破坏原有的存储空间。
07-16
要求不破坏原有存储空间，可以使用以下算法来实现两个集合的并集： 1. 定义一个新的单链表，用于存储两个集合的并集。 2. 初始化新链表为空。 3. 遍历两个集合的单链表，同时比较当前节点的值大小。 4. 如果两个节点的值相等，则将其中一个节点添加到新链表中，并分别移动到下一个节点。 5. 如果其中一个节点的值小于另一个节点的值，则将较小的节点添加到新链表中，并仅移动该节点到下一个节点。 6. 重复步骤4和步骤5，直到遍历完任一集合的单链表。 7. 将剩余未遍历完的集合的单链表中的节点依次添加到新链表中。 8. 返回新链表作为两个集合的并集。 以下是使用C语言实现该算法的代码示例： ```c #include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct Node* next; } Node; Node* createNode(int value) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = value; newNode->next = NULL; return newNode; } void insertNode(Node** head, int value) { Node* newNode = createNode(value); if (*head == NULL) { *head = newNode; } else { Node* temp = *head; while (temp->next != NULL) { temp = temp->next; } temp->next = newNode; } } void printList(Node* head) { Node* temp = head; while (temp != NULL) { printf("%d ", temp->data); temp = temp->next; } printf("\n"); } Node* setUnion(Node* list1, Node* list2) { Node* result = NULL; Node** tail = &result; while (list1 != NULL && list2 != NULL) { if (list1->data == list2->data) { insertNode(tail, list1->data); list1 = list1->next; list2 = list2->next; } else if (list1->data < list2->data) { insertNode(tail, list1->data); list1 = list1->next; } else { insertNode(tail, list2->data); list2 = list2->next; } tail = &((*tail)->next); } while (list1 != NULL) { insertNode(tail, list1->data); list1 = list1->next; tail = &((*tail)->next); } while (list2 != NULL) { insertNode(tail, list2->data); list2 = list2->next; tail = &((*tail)->next); } return result; } int main() { Node* list1 = NULL; insertNode(&list1, 1); insertNode(&list1, 3); insertNode(&list1, 5); Node* list2 = NULL; insertNode(&list2, 2); insertNode(&list2, 4); insertNode(&list2, 6); printf("List 1: "); printList(list1); printf("List 2: "); printList(list2); Node* unionList = setUnion(list1, list2); printf("Union List: "); printList(unionList); return 0; } ``` 这段代码首先定义了一个单链表的结构体Node，包含一个整数data和一个指向下一个节点的指针next。然后使用createNode函数创建一个新节点，并使用insertNode函数将节点插入到链表中。最后，使用setUnion函数实现两个集合的并集，并将结果打印出来。 注意：这段代码假设输入的两个集合已经按递增顺序排列。如果输入的集合没有排序，需要先对集合进行排序，然后再使用上述算法求并集。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

住在阳光的心里

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

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

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

打赏作者

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

抵扣说明：

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

余额充值