数据结构线性表——顺序表（C/C++(类模板））含代码

最新推荐文章于 2024-03-13 15:46:15 发布
最新推荐文章于 2024-03-13 15:46:15 发布
阅读量1.7k 收藏 28
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 代码规范 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47484802/article/details/108519911
版权

总结

就是我个人的学习总结。

  • 线性结构分为线性表（一般），栈、队列、串（特殊），数组（推广）
  • 同一线性表中的数据元素必定是具有相同的特性的，即属于同一数据对象，相邻元素间存在序偶关系。
  • 数据表其实就是一个数据对象，由n(n>=0)个数据元素构成的有限序列
  • 线性表可以分为顺序表和链表
  • 顺序表的特点：可随机存取（类似于数组）

C

//动态分配一维数组表示线性表
#include<stdio.h>
#include<stdlib.h>
#define MAX 100     //线性表的存储空间初始分配量
#define IN 10     //存储空间分配增量
typedef struct{
    int *elem;  //基址
    int length; // 表长
    int listsize;   //分配的存储容量，以sizeof(ElemType)为单位
}SqList;

线性表的基本操作实现：
1.初始化（创建）

//创建并初始化线性表
int InitList_Sq(SqList *L){
    (*L).elem=(int*)malloc(IN*sizeof(int));
    if(!(*L).elem)printf("error\n");    //空间分配失败
    (*L).length=0;                     //表长为0
    (*L).listsize=MAX;                  //初始存储容量
    return 0;
}

2.取值
跟据指定的位置序号i，获取表中第i个数据元素的值（就像数组一样通过下标定位获取元素的值）

//取位置i的元素
int GetElem_Sq(SqList L,int i,int *e){
    if(i<1||i>L.length)return 0;
    *e=L.elem[i-1];
    return 1;//返回1代表已经找到了元素，若想要输出元素，需要在加一个输出语句
}

3.查找：
根据指定元素e，查找表中第一个与e相等的元素elem[i],成功后返回i+1.

int LocateElem_Sq(SqList L,int e){
     //在表中查找第一个值与ecompare()的元素的位序
    //如若找到返回其位序，否则返回0
    int i=0;
    int j;
    int *p=L.elem;
    for(;i<L.length;i++){
     if(L.elem[i]==e)
         j=i+1;
 }
    if(i<L.length){
        return j;
    }
    return 0;
}

4.插入：

int ListInsert_Sq(SqList *L,int i,int e){
    int *newbase;
    int *p,*q;
    if(i<1||i>(*L).length)return 0;    //i值不合法
    if((*L).length>=(*L).listsize){//存储空间已满，增加分配
        newbase=(int*)realloc((*L).elem,((*L).listsize+10)*sizeof(int));
        (*L).elem=newbase;//新基址
        (*L).listsize+=10;         //增加存储容量
    }
    q=&(*L).elem[i-1];//插入元素的位置
    p=&(*L).elem[(*L).length-1];
    for(;q<=p;p--){
     *(p+1)=*p;
 }
    *q=e;              //插入
    (*L).length++;        //表长+1
    return 1;
}

5.删除：

int ListDelete_Sq(SqList *L,int i,int *e){
    //删除表中第i个元素，并用e返回其值
    int j;
    int *p,*q;
    if(i<1||i>(*L).length)return 0;//i值不合法
    p=&(*L).elem[i-1];       //p为被删除的位置
    *e=*p;                   //赋值给e
    q=(*L).elem+(*L).length-1;//表尾部元素位置
    while(p<=q){           //元素后移
        *p=*(p+1);
        ++p;
    }
    (*L).length--;   //表长-1
    return 1;
}

6.创建一个线性表（初始化）

void CreateList_Sq(SqList *L,int n){
    printf("输入%d个元素：",n);
    int i=0;
    for(;i<n;i++){
        scanf("%d",&(*L).elem[i]);
    }
    printf("\n");
    (*L).length=n;
}

7.合并两个线性表为一个：

//合并两个线性表为一个线性表
void MargsList_Sq(SqList La,SqList Lb,SqList *Lc){
    //已经知道线性表元素按值非递减顺序排列
    //归并La和Lb得到新的顺序表Lc的元素也是按值非递减排列的
    int *pa;int *pb;int *pc;int *pa_last;int *pb_last;
    pa=La.elem;pb=Lb.elem;
    (*Lc).listsize=(*Lc).length=La.length+Lb.length;
    pc=(*Lc).elem=(int *)malloc((*Lc).listsize*sizeof(int));
    if(!(*Lc).elem)exit;
    pa_last=La.elem+La.length-1;
    pb_last=Lb.elem+Lb.length-1;
    int i=0;
    for(;pa<=pa_last&&pb<=pb_last;pa++,pb++,pc++){
     if(*pa<=*pb){
      *pc=*pa;
      *(++pc)=*pb;
  }
  else{
   *pc=*pb;
   *(++pc)=*pa;
  }           
 } 
}

8.一些简单函数

//判断空表
int ListEmpty_Sq(SqList L){
    return (L.length==0);
}
//表长
int ListLength_Sq(SqList L){
    return L.length;
}
//遍历线性表
int ListTraverse_Sq(SqList L){
    int i;
    for(i=0;i<L.length-1;i++){
        printf("%d  ",L.elem[i]);
    }
    printf("\n");
}

对一些基本操作可以如下主函数检测

int main(){
    SqList L;
    int e;
    int i,a;
    if(InitList_Sq(&L)==0)printf("初始化成功！！！\n");
    if(ListEmpty_Sq(L))
        printf("顺序表为空！\n");
    for(i=0;i<10;i++){
        ListInsert_Sq(&L,i,2*i);
    }
    printf("输出所有元素：");
    ListTraverse_Sq(L);
    printf("输出表长:%d\n",ListLength_Sq(L));
    printf("输出表长是否为空：");
    if(ListEmpty_Sq(L)==1)
        printf("空表！\n");
    else
        printf("非空！\n");
    printf("输出顺序表第3个元素到e:");
    GetElem_Sq(L,3,&e);
    printf("%d\n",e);
    printf("查找元素a");
    scanf("%d",&a);
    printf("元素%d在表中的位置是：%d\n",a,LocateElem_Sq(L,a));
    printf("在表中第4个位置出入%d\n",a+1);
    ListInsert_Sq(&L,4,a+1);
    printf("输出操作后的表：\n");
     ListTraverse_Sq(L);
    printf("删除表中第3个位置的元素：\n");
    ListDelete_Sq(&L,3,&e);
    printf("输出删除的表：\n");
    ListTraverse_Sq(L);
    return 0;
}

或者是：

int main(){
    SqList L;
    int e;
    int i,a;
    if(InitList_Sq(&L)==0)printf("初始化成功！！！\n");
    CreateList_Sq(&L,10);
    printf("输出所有元素：");
    ListTraverse_Sq(L);
    printf("输出表长:%d\n",L.length);
    printf("查找元素a");
    scanf("%d",&a);
    printf("元素%d在表中的位置是：%d\n",a,LocateElem_Sq(L,a));
    printf("在表中第4个位置出入%d\n",a+1);
    ListInsert_Sq(&L,4,a+1);
    printf("输出操作后的表：\n");
    ListTraverse_Sq(L);
    printf("删除表中第3个位置的元素：\n");
    ListDelete_Sq(&L,3,&e);
    printf("输出删除的表：\n");
    ListTraverse_Sq(L);
    return 0;
}

合并俩个线性表为一个：

int main(){
    SqList La,Lb,Lc;
    int e;
    int i,a;
    InitList_Sq(&La);
    InitList_Sq(&Lb);
    InitList_Sq(&Lc);
    CreateList_Sq(&La,5);
    CreateList_Sq(&Lb,5);
    printf("输出所有元素：");
    ListTraverse_Sq(La);
    ListTraverse_Sq(Lb);
    printf("输出表长:La=%d\tLb=%d\tLc=%d\n",La.length,Lb.length,Lc.length);
    MargsList_Sq(La,Lb,&Lc);
    printf("输出表长:La=%d\tLb=%d\tLc=%d\n",La.length,Lb.length,Lc.length);
    printf("输出操作后的表：\n");
    ListTraverse_Sq(Lc);
    return 0;
}

C++类（不用模板）

代码：

typedef int DataType;
const int MaxSize=10;          //默认最大表长 
class SqList{
private: 
 DataType *elem;//首地址
 int length;   //实际表长 
 int size;      //最大表长 
public:
 //构造函数(初始化) 
 SqList(){
  size=MaxSize;
  length=0;
  elem=new DataType[size];//分配内存空间
  for(int i=0;i<size;i++){
   elem[i]=NULL;//也可以elem[i]=NULL; 
  } 
 } 
 //析构函数（销毁线性表）
 ~SqList(){
  delete[] elem; //回收内存空间 
 } 
 //基本函数声明
 bool insertelem(DataType Data); //在表尾插入元素 
 bool deleteelem(int location);//删除指定位置处的元素 
 bool changeelem(int location,DataType newData);//修改指定位置处的元素值
 DataType getelem(int location);//返回指定位置处的元素值 
 bool traverseList();//遍历 
 bool createList();//创建 
 int locateElem(DataType Data);//查找元素位置  
 //获取表长
 int lengthlist(){
  return length;
 }    
};
//函数的定义
//在表尾插入新元素
bool SqList::insertelem(DataType Data){
 if(length>=MaxSize){
  cout<<"线性表已满！"<<endl;
  return false;          
 }
 else{
  elem[length]=Data;
  length++;
  return true;
 }
} 
//删除指定位置处的元素
bool SqList::deleteelem(int location){
 if(location<0||location>length){
  cout<<"参数错误！"<<endl;
  return false;
 }
 else{
  for(int i=location-1;i<length;i++){
   elem[i]=elem[i+1];
  }
  length--;
  return true;
 }
} 
//修改指定位置处的元素值
bool SqList::changeelem(int location,DataType newData){
 if(location<0||location>length){
  cout<<"参数错误！"<<endl;
  return false;
 }
 elem[location-1]=newData;
 return true;
} 
//返回指定位置处的元素值 
DataType SqList::getelem(int location){
 if(location>length||location<0){
  cout<<"参数有误！"<<endl;
  return 0; 
 } 
 else{
  return elem[location-1];
 }
}
//遍历
bool SqList::traverseList(){
 for(int i=0;i<length;i++){
  cout<<elem[i]<<'\t';
 }
 cout<<endl;
 return true;
} 
//创建 
bool SqList::createList(){
 int k,n;
 while(1){
  cout<<"输入要输入的元素个数："<<endl;
     cin>>n;
     if(n<=size){
      break;
  }
     else {
      cout<<"输入的元素个数太大！"<<endl;
      return false;
     }
 } 
 cout<<"输入元素："<<endl; 
 for(int i=0;i<n;i++){
  cin>>k;
  insertelem(k);
 }
 return true;
} 
//查找元素位置
int SqList::locateElem(DataType Data){
 int k=0;
 for(int i=0;i<length;i++){
  if(elem[i]==Data){
   k=i+1;
   return k;
     }
 }   
    if(k==0)return 0;
}
//将两个非递减的线性表合并为一个线性表
bool MargsList(SqList L1,SqList L2,SqList &L3){
 cout<<"合并两个表为一个表！"<<endl;
 DataType p,q;
 int k=1;
 for(int i=1;i<=L1.lengthlist();i++){
  p=L1.getelem(i);
  for(int j=k;j<=L2.lengthlist();j++){
   q=L2.getelem(j);
   if(p>q){
    k=j+1;
          L3.insertelem(q);
   }
   else {
    k=j;break;
   } 
  }
  L3.insertelem(p);
 }
 return true;
}
//主函数
int main(){
 SqList L1,L2,L3;
 //初始化 
 L1.createList();
 L2.createList();  
 //输出初始化后的顺序表
 L1.traverseList();
 L2.traverseList();  
 //将顺序表索引为5的元素值改为44
 L1.changeelem(5,44);
 L2.changeelem(5,44); 
 //输出修改后的顺序表
 L1.traverseList();
 L2.traverseList(); 
 //将表L1,L2合并得到L3 
 MargsList(L1,L2,L3);
 L3.traverseList();
 return 0;
}

C++(类模板）

可以看这篇文章了解类模板的基础知识:
https://blog.csdn.net/m0_47484802/article/details/109142448
1.类模板，基本数据结构

#include<iostream>
using namespace std;
/*******线性表的数据结构********/ 
const int defaultSize=10; //设置默认顺序表大小 
template<typename DataType>
class SeqList{
private:
    DataType *elements;      //首地址 
 int maxSize;         //顺序表最大大小 
 int length;          //顺序表的有效长度 
public:
 //构造函数（初始化） 
 SeqList(int size=defaultSize){
  if(size>0){
   maxSize=size;
   length=0; 
   elements=new DataType[maxSize];//分配内存大小 
   for(int i=0;i<maxSize;i++){
    elements[i]=NULL;
   }
  }
 }
 //析构函数
 ~SeqList(){
  delete[] elements; //回收内存空间 
 }  
 //基本操作
 bool insertElement(DataType data);  //在表尾插入新元素
 bool deleteElement(int location);    //删除指定位置的元素 
 DataType getElement(int location);    //获取指定位置的元素 
 bool changeElement(int location,DataType newData);//修改指定位置处的元素值  
 int getLength(){//获取表长 
  return length;
 };
} ;

2.基本操作

//在表尾插入新元素
template<typename DataType> bool SeqList<DataType>::insertElement(DataType data){
 int currentIndex=length;//记录新元素的插入位置
 if(length>maxSize){
  return false;//表满 
 } 
 else{
  elements[currentIndex]=data;// 将新元素插入表尾
  length++;//表长加1
  return true; 
 } 
} 
 //删除指定位置的元素
template<typename DataType> bool SeqList<DataType>::deleteElement(int location){
 if(location>=length||location<0){
  return false; //判断位置是否合法 
 }
 for(int i=location;i<length;i++){
  elements[i]=elements[i+1];//从location位置开始，后一个依次覆盖前一个 
 } 
 length--;//表长减1
 return true; 
}
//获取指定位置的元素值
template<typename DataType> DataType SeqList<DataType>::getElement(int location){
 if(location>=length||location<0){
  cout<<"参数无效！\n" ;
  return false;//判断位置是否合法 
 }
 return elements[location]; //返回指定元素 
} 
//修改指定位置的元素值
template<typename DataType>bool SeqList<DataType>::changeElement(int location,DataType newData){
 if(location<0||location>=length){
  cout<<"参数无效！"<<endl;  //判断位置是否合法 
  return false; 
 }
 elements[location]=newData; //赋值 
 return true;
}

3.主函数实现

//主函数 
int main(){
 SeqList<int> list(10); //建立顺序表
 for(int i=0;i<10;i++){
  list.insertElement(i*10); //插入数据实现初始化 
 } 
 //输出初始化后的顺序表
 for(int i=0;i<list.getLength();i++){
  cout<<list.getElement(i)<<'\t';
 }
 cout<<endl;
 //将顺序表索引为5的元素值改为44
 list.changeElement(5,44);
 //输出修改后的顺序表
 for(int i=0;i<list.getLength();i++){
  cout<<list.getElement(i);
  cout<<'\t';
 } 
 cout<<endl;
 return 0;
}
蛟～
关注
  • 3
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++数据结构之线性表（自定义数组）
GGGGG1233的博客
03-13 521
首先利用抽象类LinearList来定义定义一个线性表 template<class T> class LinearList { public: virtual ~LinearList() {}; virtual bool empty()const = 0; virtual int size()const = 0; virtual T &Getelement(int index)const = 0;//返回index下标处元素 virtual int ElementPos(c
数据结构实验报告(C++) 实验一 线性结构实验指导
01-04
一、线性结构实验（1）——线性表 题目1. 顺序表的差集 题目2. 单链表的递增差集 题目3.(选做题)：不带头结点的单链表 题目4.：单链表逆置 二、线性结构实验（2）——栈和队列 题目1. 队列元素倒置 题目2. 双端顺序...
线性表之顺序表的c++代码
Riley_chen的博客
10-26 814
在我们的函数实现上参数，全部是位序，在别人使用函数的时候全是使用的是该数组的实际第几位，而类里面的length, maxlength当前长度和最大长度也是位序，而到了L[]数组上的时候就全是位序-1了。线性表由于物理存储方式的不同有两种：顺序表和链表。我的这个数组是要是超过了其当前的最大存储量，就自动扩大容量，但是我初始化的时候又专门设置了一个最大容量，很奇怪总觉得逻辑有点冲突。2、线性表就是线性的连续的，所以不存在有 数组第1~10位的数据，要插入一个第100位的数据，只能最大插入到到11位。
【数据结构C++】线性表/顺序表-实战：通信录
最新发布
JingYan_Chan的博客
03-13 670
这篇blog面向刚入门学习数据结构的小伙伴们，参考第二章的函数模板可以实现这个通信录的项目。按照下面步骤，不需任何修改就可以顺利编译。
C++实现数据结构——线性表
qq_63058205的博客
11-10 1639
本次实验主要采用顺序表中的线性表的知识来进行实验，运用了线性表相关操作的声明和实现，如增删改查等。
用C++编写线性表
Whynotwu的博客
10-27 2800
数据结构：用C++编写顺序表 数据结构实验心得 用c++语言编写一段程序，以实现顺序表的功能：元素的插入、删除、追加。 实验心得： 本次的实验让我对于顺序表有了更深的理解，顺序表是通过数据元素物理存储的连续性。来反应元素之间逻辑上的相邻关系。采用顺序存储结构存储的线性表。 元素的追加只需要在尾部处增加一个地址，顺序表的长度增大一，把值赋给该地址。 元素的插入稍微复杂一点，要先判断插入的位置...
C++数据结构补充（线性表及其顺序存储结构）
Lao_tan的博客
06-27 346
C++ 数据结构顺序表
线性表（C++数据结构）
weixin_48434899的博客
08-20 2303
文章目录数据描述 数据描述 数据可以用不同的形式进行描述或存储在计算机存储器中，最常见的数据描述方法有：公式化描述、链接描述、间接寻址和模拟指针。 数据结构的概念： 抽象数据类型。 公式化描述、链接描述、间接寻址和模拟指针。 单向链表、循环链表和双向链表。 ...
C/C++线性表的实现
m0_54202580的博客
09-26 8441
新手出路，多多请教！！ 线性表的定义： 线性表（linear list）是最基本、最简单、最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的，但这只适用大部分线性表，而不是全部。在数据结构逻辑层次上细分，线性表可分为一般线性表和受限线性表。 线性表的功能以下： ======1.输入数据====== ======2.输出数据====== ======3.插入数据====== ======4.查找指定位置的元素====== =
C++用类实现线性表(保姆级教你从0到封装一个SeqList类，附源码)
m0_51510934的博客
11-12 3200
[着急用代码的直接拿] （线性表（非链表）源码网盘链接：https://pan.baidu.com/s/1SbzGBK0Cv3nV3q14yUhDBw 提取码：s51t 链表源码网盘链接：https://pan.baidu.com/s/1dhd7Lvcd3yhC5nzcVzWTyA 提取码：zdzn） 1.什么是线性表 何谓线性表呢？先看一手百度的解释： 扯白了线性表就是一种序列并且其长度是作为它本...
【数据结构C++】线性表（一）顺序存储结构
qq_45397526的博客
03-28 1109
线性表是数据结构入门的第一课，其也是最基本、最常用的一种数据结构 文章目录一、什么是线性表二、顺序存储结构ADT实现1、什么是顺序存储结构2、顺序存储结构的实现（1）、存储方式（2）、具体实现1）、模板类的实现2）、带参数的构造函数3）、查找X在表中的位置4）、在第i个元素插入X 一、什么是线性表 线性表(Linear_List)：n(n≥0)个相同特性的数据元素的有限序列，数据元素之间具有线性关...
2021-12-18 数据结构——线性表(上) (c++代码和c代码)
名幕新星的博客
12-17 1248
线性表是最基本、最简单、也是最常用的一种数据结构。==线性表（linear list）==是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。 1.基本概念 线性表：零个或多个数据元素的有限序列。 线性表：包括顺序表和链表 顺序表（数组）：里面元素的地址是连续的， 链表：链表里面节点的地址不是连续的，是通过指针连起来的。 表中元素个数称为线性表的长度 线性表没有元素时，称为空表 表起始位置称为表头，表结束位置称表尾 2. 线性表的抽象数据类型 类型名称：线性表（List） 操作集：线性表 L
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
*5.6 C＋＋处理字符串的方法——字符串类与字符串变量 5.6.1 字符串变量的定义和引用 5.6.2 字符串变量的运算 5.6.3 字符串数组 5.6.4 字符串运算举例 习题 第6章 指针 6.1 指针的概念 6.2 变量与指针 6.2.1 定义...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar )
06-13
*5.6 C＋＋处理字符串的方法——字符串类与字符串变量 5.6.1 字符串变量的定义和引用 5.6.2 字符串变量的运算 5.6.3 字符串数组 5.6.4 字符串运算举例 习题 第6章 指针 6.1 指针的概念 6.2 变量与指针 6.2.1 定义...
数据结构算法与应用-C C++语言描述
11-19
第二部分 数据结构 第3章 数据描述 75 3.1 引言 75 3.2 线性表 76 3.3 公式化描述 77 3.3.1 基本概念 77 3.3.2 异常类NoMem 79 3.3.3 操作 79 3.3.4 评价 83 3.4 链表描述 86 3.4.1 类ChainNode 和Chain 86 3.4.2 ...
数据结构之线性表（C++实现）
qq_47471199的博客
09-10 1013
顺序表 函数声明 List.h（顺序表的定义，各项功能和变量） #pragma once #ifndef LIST_H #define LIST_H #endif #define Elem int class List { public: List(int size);//创建线性表 ~List();//销毁线性表 void ClearList();//清空线性宝 bool ListEmpty();//判断线性表是否为空 int ListLengh();//获取线性表的长度 bool GetE
数据结构与算法C++描述（1）---线性表的基本操作
Hello~~~
09-15 3120
本文将利用公式化描述的方法，借助于C++语言，建立线性表，实现线性表的创建、删除、元素插入、线性表的合并与拆分等操作。 文中所有代码皆上传至我的码云1、 线性表的定义在参考文献[1]中，对线性表有如下定义：线性表（linear list）是这样的数据对象，其实例形式为：(e1,e2,…,en)，其中n是有穷自然数。ei是表中的元素，n是表的长度。元素可以被视为原子，因为它们本身的结构与线性表的结构
C++实现数据结构入门01——顺序存储实现线性表
小橙子的博客
11-11 1065
参考书：《数据结构》C语言版（第2版） 一、初始化 1.简写初始化 #include <iostream> using namespace std; int main(){ //==============01准备工作============= //创建数组 const int MAXSIZE = 100;//设置数据的长度 int arr[MAXSIZE] = {};//开辟100个整型的数组空间。 int length = 0;//存储线性表有多少个元素
线性表 c++语言代码,C、C++线性表基本操作的详细介绍
weixin_35639680的博客
05-22 699
前言线性表包括两部分顺序表和链表，是数据结构的基础，在此主要就算法进行分析和总结，作为记忆了解，未做具体实现。提示：以下是本篇文章正文内容，下面案例可供参考一、顺序表#define LISST_INIT_SIZE 100#define LISTINCREMENT 10#define OK 0#define OVERFLOW 1typedef int ElemType;typedef int Sta...
c++数据结构线性表的顺序查找和折半查找
05-27
// 存储数据的数组指针 int length; // 线性表长度 }; ``` 接下来，我们实现顺序查找： ```c++ // 顺序查找 int sequentialSearch(LinearList list, int key) { for (int i = 0; i ; i++) { if (list.data[i] ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值