C语言线性表

已于 2022-10-04 18:56:18 修改
阅读量350 收藏
点赞数 1
分类专栏： 数据结构 文章标签： c语言 算法 c++
于 2022-10-02 11:20:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44368660/article/details/127141197
版权

线性表

/* 宏定义 */
#define LIST_INIT_SIZE 100				//顺序表存储空间的初始分配量 
#define LISTINCREMENT  10				//顺序表存储空间的分配增量

/* 顺序表类型定义 */
#ifndef LELEMTYPE_SQ
#define LELEMTYPE_SQ
typedef int LElemType_Sq;
#endif

typedef struct
{
	LElemType_Sq *elem;					//存储空间基址（指向第一个结点的指针） 
	int length;							//当前顺序表长度 
	int listsize;						//当前分配的存储容量 
}SqList;								//顺序表0号单元正常使用

线性表基本操作

Status InitList_Sq(SqList *L)
{
	(*L).elem = (LElemType_Sq*)malloc(LIST_INIT_SIZE*sizeof(LElemType_Sq));
	if(!(*L).elem)
		exit(OVERFLOW); 				//分配内存失败

	(*L).length = 0;					//初始化顺序表长度为0
	(*L).listsize = LIST_INIT_SIZE;		//顺序表初始内存分配量

	return OK;							//初始化成功	 
} 

void ClearList_Sq(SqList *L)
{
	(*L).length = 0;
}

void DestroyList_Sq(SqList *L)
{
	free((*L).elem);

	(*L).elem = NULL;					//释放内存后置空指针 
	(*L).length = 0;
	(*L).listsize = 0;
}

Status ListEmpty_Sq(SqList L)
{
	return 	L.length==0 ? TRUE : FALSE;
}

int ListLength_Sq(SqList L)
{
	return L.length;	
}

Status GetElem_Sq(SqList L, int i, LElemType_Sq *e)
{ 
	if(i<1 || i>L.length)
		return ERROR;					//i值不合法
	else
		*e = L.elem[i-1];

	return OK;
}

/*════╗
║算法2.6 ║ 
╚════*/
int LocateElem_Sq(SqList L, LElemType_Sq e, Status(Compare)(LElemType_Sq, LElemType_Sq))
{
	int i = 1;							//i的初值为第一个元素的位序
	
	while(i<=L.length && !Compare(e, L.elem[i-1]))
		++i;

	if(i<=L.length)
		return i;
	else
		return 0; 
}

Status PriorElem_Sq(SqList L, LElemType_Sq cur_e, LElemType_Sq *pre_e)
{
	int i = 1;
	
	if(L.elem[0]!=cur_e)				//第一个结点无前驱 
	{
		while(i<L.length && L.elem[i]!=cur_e)
			++i;
		
		if(i<L.length)
		{
			*pre_e = L.elem[i-1];
			return OK;
		}	
	}
			
	return ERROR;
}

Status NextElem_Sq(SqList L, LElemType_Sq cur_e, LElemType_Sq *next_e)
{
	int i = 0;
	
	while(i<L.length && L.elem[i]!=cur_e)
		++i;

	if(i<L.length-1)					//最后一个结点无后继 
	{
		*next_e = L.elem[i+1];	
		return OK;
	}

	return ERROR;
}

/*════╗
║算法2.4 ║ 
╚════*/
Status ListInsert_Sq(SqList *L, int i, LElemType_Sq e)
{
	LElemType_Sq *newbase; 
	LElemType_Sq *p, *q;

	if(i<1 || i>(*L).length+1)
		return ERROR;					//i值不合法

	if((*L).length >= (*L).listsize)	//若存储空间已满，需开辟新空间 
	{
		newbase = (LElemType_Sq*)realloc((*L).elem, ((*L).listsize+LISTINCREMENT)*sizeof(LElemType_Sq));
		if(!newbase)
			exit(OVERFLOW);

		(*L).elem = newbase;
		(*L).listsize += LISTINCREMENT;
	}
	
	q = &(*L).elem[i-1];				//q为插入位置 
	
	for(p=&(*L).elem[(*L).length-1]; p>=q; --p)
		*(p+1) = *p;					//插入位置及之后的元素右移 
	
	*q = e;								//插入e 
	(*L).length++;						//表长增1

	return OK; 
}

/*════╗
║算法2.5 ║ 
╚════*/
Status ListDelete_Sq(SqList *L, int i, LElemType_Sq *e)
{
	LElemType_Sq *p, *q;
		
	if(i<1 || i>(*L).length)
		return ERROR;					//i值不合法
	
	p = &(*L).elem[i-1];				//p为被删除元素的位置 
	*e = *p;
	q = (*L).elem+(*L).length-1; 		//表尾元素位置 
	
	for(++p; p<=q; ++p)
		*(p-1) = *p;					//被删元素之后的元素左移 

	(*L).length--;						//表长减1

	return OK;
}

Status ListTraverse_Sq(SqList L, void(Visit)(LElemType_Sq))
{
	int i;

	for(i=0; i<L.length; i++)
		Visit(L.elem[i]);
	
	return OK;
}

/* 测试调用的函数原型 */
Status CmpGreater(LElemType_Sq e, LElemType_Sq data);
	//若data>e，返回TRUE，否则返回FALSE
	
void PrintElem(LElemType_Sq e);
	//测试函数，打印整型 

int main(int argc, char **argv)
{
	SqList L;
	int i;
	LElemType_Sq e;

	printf("▼1\n▲函数 InitList_Sq 测试...\n");		//1.函数InitList_Sq测试
	{
		printf("初始化顺序表 L ...\n");					 
		InitList_Sq(&L);
		printf("\n");	
	}
	PressEnter;
	
	printf("▼4\n▲函数 ListEmpty_Sq 测试...\n");		//4.函数ListEmpty_Sq测试
	{
		ListEmpty_Sq(L) ? printf(" L 为空！！\n") : printf(" L 不为空！\n");
		printf("\n");	
	}
	PressEnter;
		
	printf("▼10\n▲函数 ListInsert_Sq 测试...\n");		//10.函数ListInsert_Sq测试
	{
		for(i=1; i<=6; i++)									
		{
			printf("作为示范，在 L 第 %d 个位置插入 \"%d\"...\n", i, 2*i);
			ListInsert_Sq(&L, i, 2*i);
		}
		printf("\n");	
	}
	PressEnter;
			
	printf("▼12\n▲函数 ListTraverse_Sq 测试...\n");	//12.函数ListTraverse_Sq测试
	{
		printf(" L 中的元素为：L = ");						 
		ListTraverse_Sq(L, PrintElem);
		printf("\n\n");	
	}
	PressEnter;
		
	printf("▼5\n▲函数 ListLength_Sq 测试...\n");		//5.函数ListLength_Sq测试
	{
		i = ListLength_Sq(L);
		printf(" L 的长度为 %d \n", i);
		printf("\n");	
	}
	PressEnter;
			
	printf("▼11\n▲函数 ListDelete_Sq 测试...\n");		//11.函数ListDelete_Sq测试
	{
		ListDelete_Sq(&L, 6, &e);
		printf("删除 L 中第 6 个元素 \"%d\" ...\n", e);
		printf(" L 中的元素为：L = ");						 
		ListTraverse_Sq(L, PrintElem);
		printf("\n\n");
	}
	PressEnter;
		
	printf("▼6\n▲函数 GetElem_Sq 测试...\n");			//6.函数GetElem_Sq测试
	{
		GetElem_Sq(L, 4, &e);
		printf(" L 中第 4 个位置的元素为 \"%d\" \n", e);
		printf("\n");
	}
	PressEnter;
		
		
	printf("▼7\n▲函数 LocateElem_Sq 测试...\n");	  	//7.函数LocateElem_Sq测试
	{
		i = LocateElem_Sq(L, 7, CmpGreater);
		printf(" L 中第一个元素值大于 \"7\" 的元素的位置为 %d \n", i); 
		printf("\n");
	}
	PressEnter;
		
	printf("▼8\n▲函数 PriorElem_Sq 测试...\n");		//8.函数PriorElem_Sq测试
	{
		PriorElem_Sq(L, 6, &e);
		printf("元素 \"6\" 的前驱为 \"%d\" \n", e);
		printf("\n");
	}
	PressEnter;
		
	printf("▼9\n▲函数 NextElem_Sq 测试...\n");		//9.函数NextElem_Sq测试
	{
		NextElem_Sq(L, 6, &e);
		printf("元素 \"6\" 的后继为 \"%d\" \n", e);
		printf("\n");
	}
	PressEnter;
		
	printf("▼2\n▲函数 ClearList_Sq 测试...\n");		//2.函数ClearList_Sq测试
	{
		printf("清空 L 前：");
		ListEmpty_Sq(L) ? printf(" L 为空！！\n") : printf(" L 不为空！\n");		
		ClearList_Sq(&L);
		printf("清空 L 后：");
		ListEmpty_Sq(L) ? printf(" L 为空！！\n") : printf(" L 不为空！\n");
		printf("\n");
	}
	PressEnter;
		
	printf("▼3\n▲函数 DestroyList_Sq 测试...\n");		//3.函数DestroyList_Sq测试
	{
		printf("销毁 L 前：");
		L.elem ? printf(" L 存在！\n") : printf(" L 不存在！！\n");
		DestroyList_Sq(&L);
		printf("销毁 L 后：");
		L.elem ? printf(" L 存在！\n") : printf(" L 不存在！！\n");
		printf("\n");
	}
	PressEnter;
		
	return 0;
}

Status CmpGreater(LElemType_Sq e, LElemType_Sq data)
{
	return data>e ? TRUE : FALSE;
}

void PrintElem(LElemType_Sq e)
{
	printf("%d ", e);
}

线性表并集∪

/*════╗
║ 算法2.1║ 
╚════*/
void Union(SqList *La, SqList Lb)
{
	int La_len, Lb_len;
	int i;
	LElemType_Sq e;
	
	La_len = ListLength_Sq(*La);			//求顺序表长度 
	Lb_len = ListLength_Sq(Lb);
	
	for(i=1; i<=Lb_len; i++)
	{
		GetElem_Sq(Lb, i, &e);				//取Lb中第i个元素赋给e 
		if(!LocateElem_Sq(*La, e, equal)) 	//若e不在La中则插入
			ListInsert_Sq(La, ++La_len, e);	
	}
}

Status equal(LElemType_Sq e1, LElemType_Sq e2)
{
   return e1==e2 ? TRUE : FALSE;
}

void PrintElem(LElemType_Sq e);		//测试函数，打印整型 
	
int main(int argc, char **argv)
{
	SqList La, Lb;
	LElemType_Sq a[5] = {5, 2, 1, 3, 9};
	LElemType_Sq b[7] = {7, 2, 6, 9, 11, 3, 10};
	int i;
	
	InitList_Sq(&La);					//初始化La 
	for(i=1; i<=5; i++)
		ListInsert_Sq(&La, i, a[i-1]);	
	InitList_Sq(&Lb);					//初始化Lb 
	for(i=1; i<=7; i++)
		ListInsert_Sq(&Lb, i, b[i-1]);

	printf("La = ");					//输出La 
	ListTraverse_Sq(La, PrintElem); 
	printf("\n");
	printf("Lb = ");					//输出Lb 
	ListTraverse_Sq(Lb, PrintElem); 
	printf("\n\n");
	
	printf("La = La∪Lb = ");			//输出新表La的内容
	Union(&La, Lb);
	ListTraverse_Sq(La, PrintElem);
	printf("\n\n");
	
	return 0;
}

void PrintElem(LElemType_Sq e)
{
	printf("%d ", e);
}

线性表合并

/*━━━━━━━━━━━━━━━━━━━━━┓
┃算法2.2：求C=A+B，A,B,C均为非递减序列 ┃
┗━━━━━━━━━━━━━━━━━━━━━*/
void MergeSqList_1(SqList La, SqList Lb, SqList *Lc)	//调用顺序表函数进行合并 
{
	int La_len, Lb_len; 
	int i, j, k;
	LElemType_Sq ai, bj;
	
	i = j = 1;
	k = 0;
	
	InitList_Sq(Lc);					//初始化Lc	
	La_len = ListLength_Sq(La);			//获取La、Lb长度 
	Lb_len = ListLength_Sq(Lb);	 

	while(i<=La_len && j<=Lb_len)		//La及Lb均未扫描完 
	{
		GetElem_Sq(La, i, &ai);
     	GetElem_Sq(Lb, j, &bj);
     	
     	if(ai<=bj)
     	{
     		ListInsert_Sq(Lc, ++k, ai);
     		i++;
     	}
     	else
     	{
			ListInsert_Sq(Lc, ++k, bj);
			j++;
		}
	} 
	
	while(i<=La_len)					//表La还未扫描完 
	{
		GetElem_Sq(La, i++, &ai);
		ListInsert_Sq(Lc, ++k, ai);
	}
   
	while(j<=Lb_len)					//表Lb还未扫描完
	{
		GetElem_Sq(Lb, j++, &bj);
		ListInsert_Sq(Lc, ++k, bj);
	}
}

/*━━━━━━━━━━━━━━━━━━━━━┓
┃算法2.7：求C=A+B，A,B,C均为非递减序列 ┃
┗━━━━━━━━━━━━━━━━━━━━━*/
void MergeSqList_2(SqList La, SqList Lb, SqList *Lc)
{
	LElemType_Sq *pa, *pb, *pc;
	LElemType_Sq *pa_last, *pb_last;
		
	pa = La.elem;						//指向La第一个元素 
	pb = Lb.elem;						//指向Lb第一个元素
	
										//不用InitList_Sq创建Lc 
	(*Lc).listsize = (*Lc).length = La.length + Lb.length;
	pc = (*Lc).elem = (LElemType_Sq *)malloc((*Lc).listsize*sizeof(LElemType_Sq));
	if(!pc) 
		exit(OVERFLOW);
	
	pa_last = La.elem + La.length - 1;	//指向La最后一个元素
	pb_last = Lb.elem + Lb.length - 1;	//指向Lb最后一个元素
	
	while(pa<=pa_last && pb<=pb_last) 	//La和Lb均未扫描完 
	{
		if(*pa <= *pb)
			*pc++ = *pa++;
		else
			*pc++ = *pb++;
	}
	
	while(pa <= pa_last)				//表La未扫描完 
		*pc++ = *pa++;					//插入La的剩余元素

	while(pb <= pb_last)				//表Lb未扫描完
		*pc++ = *pb++;					//插入Lb的剩余元素
}

void PrintElem(LElemType_Sq e);			//测试函数，打印整型 
	
int main(int argc, char **argv)
{
	SqList La, Lb, Lc1, Lc2;
	LElemType_Sq a[4] = {3, 5, 8, 11};
	LElemType_Sq b[7] = {2, 6, 8, 9, 11, 15, 20};
	int i;
	
	InitList_Sq(&La);					//初始化La 
	for(i=1; i<=4; i++)
		ListInsert_Sq(&La, i, a[i-1]);	
	InitList_Sq(&Lb);					//初始化Lb 
	for(i=1; i<=7; i++)
		ListInsert_Sq(&Lb, i, b[i-1]);

	printf("La = ");					//输出La 
	ListTraverse_Sq(La, PrintElem); 
	printf("\n");
	printf("Lb = ");					//输出Lb 
	ListTraverse_Sq(Lb, PrintElem); 
	printf("\n\n");
	
	MergeSqList_1(La, Lb, &Lc1);		//合并A与B,算法2.6 
	printf("合并La和Lb为Lc1 = "); 		//输出Lc1 
	ListTraverse_Sq(Lc1, PrintElem);
	printf("\n\n");

	MergeSqList_2(La, Lb, &Lc2);		//合并A与B,算法2.7  
	printf("合并La和Lb为Lc2 = "); 		//输出Lc2 
	ListTraverse_Sq(Lc2, PrintElem);
	printf("\n\n");
	
	return 0;
}

void PrintElem(LElemType_Sq e)
{
	printf("%d ", e);
}
取个名字真难啊啊
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
c语言线性表创建步骤,实例详解C语言线性表的顺序与实现步骤
weixin_42322512的博客
05-18 3046
数据结构中，线性表是一种入门级的数据结构，线性表分为序列表和链表，在下文中爱站技术频道小编将实例详解C语言线性表的顺序与实现步骤，下面一起跟着爱站技术频道的步伐来学习吧！1.概述通常来说顺序表是在计算机的内存中以数组的形式保存的线性表，是用一组地址连续的存储单元依次存储数据元素的线性数据结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单...
c语言线性表
huang_c_c的博客
02-20 427
线性表 线性表：零个或多个数据元素的有限序列。 注意： 1线性表有序 元素之间有序列。若元素存在多个，则第一个无前驱，最后一个无后驱，其他元素仅有一个前驱和后驱。 2.线性表有限 数列之内的数据有限。无限的数列只存在于数学概念之中。 所以线性表元素个数n就定义为线性表的长度，当n=0时，为空表。 线性表的两种物理结构： 一.顺序存储结构： 1.定义 用一段地址连续的存储单元依次存储线性表的数据结构...
c语言线性表插入,线性表的插入删除
weixin_31874327的博客
05-21 1408
已结贴√问题点数：20回复次数：6 线性表的插入删除#include"stdio.h"#include"stdlib.h"int*inistl(int m,int *n){int*v=NULL;v=malloc(m*sizeof(int*));n=0;return v;}void insl(int*v,int m,int*n,int i,int b){int j;if(*n>=m){pr...
c语言 线性表
凡事都是靠练习
02-05 280
线性表的创建 数据插入与删除 链表与线性表的对比
C语言线性表last,线性表（C语言）
weixin_42439808的博客
05-22 1336
线性表是最基本、最简单、也是最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的(注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表(存储层次上属于链式存储)，但是把最后一个数据元素的尾指针指向了首位结点)。线性表的两种存储方式顺序存储链式存储线性表的顺序存储typedef struct Li...
数据结构C语言 线性表
kkh01421的博客
08-29 4873
一、线性表的概念及运算 （一）线性表的逻辑结构 线性表是n个数据元素的有限序列。表中元素存在线性关系。根据它们之间的关系可以构成一个线性序列，记作 （a1,a2,...an) 线性表中的元素具有相同的数据类型。线性表中数据元素的个数n定义为线性表的长度，称为表长。n=0时成为空表。ai是第i个数据元素，称i为位序。 （二）线性表的运算 线性表有以下基本运算 1、Inilist():线性表初始化，构造一个空的线性表L。 2、ListLength(L):求线性表的长度，返回线性表L中元素个数。 3
C语言线性表插入删除操作
weixin_46503238的博客
04-19 4925
#include <stdio.h> #include <stdlib.h> #define MAXSIZE 20 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 /* 线性表起始长度从1开始,本质是封装一个数组 */ typedef int Status; // typedef 关键字来定义自己习惯的数据类型名称，来替代系统默认的基本类型名称、数组类型名称、指针类型名称与用户自定义的结构型名称、共用型
C语言 线性表的基本操作
weixin_51528408的博客
10-02 3232
一、线性表的定义 线性表是一种最常用也是最简单的数据结构。简单来讲，一个线性表是n个数据元素的有限排列，在不同情况下，每个数据元素有着不同的含义。 二、线性表的组成 一个线性表的结构体由三部分组成：1.线性表中的元素（Elem）2.线性表的当前长度（Length）3、线性表当前分配的储存空间大小（ListSize，通常情况下ListSize>Length） 三、头文件以及数据的定义 #include<stdio.h> #include<stdlib.h> #include&lt
c语言线性表的逆转,用C语言编写线性表的逆置的程序.
weixin_36348900的博客
05-22 1274
#include #define ok 1#define error 0#define true 1#define false 0第二个文件seqlist.h#define elemtype int#define maxsize 100 /*此处的宏定义常量表示线性表可能达到的最大长度*/typedef struct{elemtype elem[maxsize]; /*线性表占用...
c语言线性表的逆序输出,C语言创建一个线性表，然后输出线性表，如何编写程序？...
weixin_31874327的博客
05-22 1392
匿名用户1级2017-12-26 回答#include#include#include#defineOVERFLOW -2#define OK 1#define ERROR 0#defineLIST_INIT_SIZE 100#defineLISTINCREMENT 10typedef intElemType;typedef intStatus;//定义顺序存储结构typedef struct{E...
C语言线性表顺序存储结构实例详解
01-20
C语言线性表顺序存储结构实例详解 1、 什么是顺序存储结构？ 用一段地址连续的存储单元依次存储线性表的数据元素。 2、线性表的顺序存储结构 #include #include #define Max 80 //存储空间初始分配量 #define ...
C语言线性表的顺序表示与实现实例详解
09-04
主要介绍了C语言线性表的顺序表示与实现实例详解，对于学习数据结构与算法的朋友很有参考借鉴价值,需要的朋友可以参考下
C语言线性表结构实验
11-06
（2）掌握线性表的顺序存储结构的定义及C语言实现。 （3）掌握线性表在顺序存储结构即顺序表中的各种基本操作。 2．问题描述： 假设两线性表LA和LB分别表示两集合A和B，要求新集合A=AB。 3． 数据输入: 由文件...
数据结构 c语言 线性表 增删查改保存.txt
07-24
数据结构 c语言 线性表 增删查改保存 InitList(Linklist &L,int &k); PrintList(Linklist &L,int &k); ListInsert(Linklist &L,int &k); ListDelete(Linklist &L,int &k); void ListSave(Linklist &L); void cd();
比大小（打擂台）（C语言）
m0_67184754的博客
05-14 214
【代码】比大小（打擂台）（C语言）
c语言：递归与迭代
qq_58761784的博客
05-14 1089
它却没有得出结果，这是为什么呢，因为，函数在内部多次调用了自己，产生了大量的重复计算，导致计算量巨大，代码执行效率非常低，让计算机也无法快速得出结果，这个例子告诉我们，递归是有使用条件的 ，如果要设计一个需要重复计算的程序，不能无脑使用递归，而是首先要思考递归能不能用，是否能让代码简洁的同时，更加高效，那么此类例子我们如何解决呢？可以看到，很快就得到了结果，但是答案是错误的，因为要求的数太大，一个字节无法表示，但是我们可以很直观的看见两者的差别，在这这样一个例子中，使用迭代会优于使用递归。
手撕C语言题典——链表的中间节点
Antigonos的博客
05-14 401
链表的中间节点同样也是力扣上一道简单题，适合刚学过单链表的我们更好的理解链表相关知识~
[每日一题]169：找出最大的可达成数字
AngelDg的博客
05-21 217
题目要求得一个最大的整数 x，使其在不超过 t 次操作内变成与 num 相等的数字。每次操作可以选择将 x 增加或减少 1，同时可以选择将 num 增加或减少 1。返回所有可达成数字中的最大值。可以证明至少存在一个可达成数字。给你两个整数 num 和 t。
质数和约数
最新发布
2302_77099705的博客
05-21 698
最大公约数（Greatest Common Divisor）指两个或多个整数共有约数中最大的一个。也称最大公因数、最大公因子，a， b的最大公约数记为（a，b），同样的，a，b，c的最大 公约数记为（a，b，c），多个 整数的最大公约数也有同样的记号。求最大公约数有多种 方法，常见的有 质因数分解法、 短除法、 辗转相除法、 更相减损法。
数据结构c语言线性表
10-26
C语言中的线性表是一种常见的数据结构，它是由一组相同数据类型的元素组成的有限序列。线性表中的元素按照线性的顺序排列，每个元素都有一个前驱和一个后继，除了第一个元素没有前驱，最后一个元素没有后继。 在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

取个名字真难啊啊

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

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

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

打赏作者

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

抵扣说明：

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

余额充值