数据结构之线性表

最新推荐文章于 2020-01-03 15:44:01 发布
最新推荐文章于 2020-01-03 15:44:01 发布
阅读量206 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表 算法 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44161383/article/details/103627468
版权

一，实现顺序表的各种基本运算

#include<stdio.h>
#include<stdlib.h>
#define ElemType char
#define MaxSize 50
typedef struct 
{
	ElemType data[MaxSize];
	int length;
}Sqlist;
void CreatList(Sqlist *&L,ElemType a[],int n)
{
	int i=0,k=0;
	L=(Sqlist *)malloc(sizeof(Sqlist));
	while(i<n)
	{
		L->data[k]=a[i];
		k++;i++;
	}
	L->length=k;
	printf("创建成功\n\n");
}
void InitList(Sqlist *&L)
{
	L=(Sqlist *)malloc(sizeof(Sqlist));
	L->length=0;
	printf("初始化成功\n");
}
void DestroyList(Sqlist *L)
{
	free(L);
	printf("销毁成功\n");

}
void DispList(Sqlist *L)
{
	for(int i=0;i<L->length;i++)
		printf("%c   ",L->data[i]);
	printf("\n");
}
bool ListEmpty(Sqlist *L)
{
	if(L->length==0)
		return false;
	else
		return true;
}
int ListLength(Sqlist *L)
{
	return(L->length);
	printf("%d",L->length);
}
bool GetElem(Sqlist *L,int i,ElemType &e)
{
	if(i<1||i>L->length)
		return false;
	e=L->data[i-1];
	printf("%c  ",e);
	return true;
}
int LocateElem(Sqlist *L,ElemType e)
{
	int i=0;
	while(i<L->length&&L->data[i]!=e)
		i++;
	if(i>=L->length)
		return 0;
	else
		return (i+1);
		
}
bool ListInsert(Sqlist *L,int i,ElemType e)
{
	int j;
	if(i<1||i>L->length+1)
		return false;
	i--;
	for(j=L->length;j>i;j--)
	{
		L->data[j]=L->data[j-1];
	}
	L->data[i]=e;
	L->length++;
	return true;
}
bool ListDelete(Sqlist *L,int i,ElemType &e)
{
	//ListEmpty(L);
	if(i<1||i>L->length)
		return false;
	int j;
	i--;
	e=L->data[i];
	for(j=i;j<L->length-1;j++)
	{
		L->data[j]=L->data[j+1];
	}
	L->length--;
	printf("删除成功\n");
	return true;
}
int main()
{
	int num;
	int i;
	char a,b,c,d,e,f,j,x,y;
	Sqlist *L;
	char A[50]={0};
	CreatList(L,A,50);
	InitList(L);
	printf("请插入a,b,c,d,e五个元素\n");
	for(i=1,j='a';i<6;i++,j++)
		ListInsert(L,i,j);
	DispList(L);
	printf("插入成功\n");
	printf("请输入你要进行的操作\n");
	while(scanf("%d",&num))
	{
	switch(num)
	{
	case 1:
		printf("输出元素a的位置\n");
		printf("%d\n",LocateElem(L,'a')); 	
		break;
	case 2:
		printf("取出第3个元素\n");
		GetElem(L,3,x);
		printf("\n");
		break;
	case 3:
		printf("在第四个元素位置上插入f\n");
		ListInsert(L,4,'f');
		DispList(L);
		printf("插入成功\n");
		break;
	case 4:
		printf("删除第3个元素\n");
		ListDelete(L,3,y);
		DispList(L);
		printf("删除成功\n");
		break;
	case 5:
		DestroyList(L);
		break;
	default:
		break;
	}
	}
	system("pause");
	return 0;
}

在这里插入图片描述

二，实现单链表的各种基本运算的算法

(1)

#include <stdio.h>
#include <stdlib.h>

typedef char ElemType;
typedef struct LNode
{
    ElemType data;          // 数据域
    struct LNode *next;     // 指针域
}LinkList;                  // 定义单链表结点类型

/*-----------------------初始化单链表-----------------------*/
void InitList(LinkList *&L)
{
    L = (LinkList *)malloc(sizeof(LinkList));       // 创建头结点
    L->next = NULL;
}

/*----------------------释放单链表-----------------------*/
void DestroyList(LinkList *&L)
{
    LinkList *p = L, *q = p->next;

    while(q != NULL)
    {
        free(p);
        p = q;
        q = p->next;
    }
    free(p);
}

/*----------------------判断单链表是否为空-----------------------*/
int ListEmpty(LinkList *L)
{
    return (L->next == NULL);
}

/*----------------------返回单链表的元素个数-----------------------*/
int ListLength(LinkList *L)
{
    int i = 0;
    LinkList *p = L;

    while(p->next != NULL)
    {
        i++;
        p = p->next;
    }

    return (i);
}

/*----------------------输出单链表-----------------------*/
void DispList(LinkList *L)
{
    LinkList *p = L->next;

    while(p != NULL)
    {
        printf("%c ", p->data);
        p = p->next;
    }
    printf("\n");

}

/*----------------------获取单链表L中第i个元素------------------------*/
int GetElem(LinkList *L, int i, ElemType &e)
{
    int j = 0;
    LinkList *p = L;

    while((j < i) && (p != NULL))
    {
        j++;
        p = p->next;
    }
    if(p == NULL)
        return 0;
    else
    {
        e = p->data;
        return 1;
    }
}

/*-------------------在单链表L中查找元素e--------------------*/
int LocateElem(LinkList *L, ElemType e)
{
    LinkList *p = L->next;
    int n = 1;

    while((p != NULL) && (p->data != e))
    {
        p = p->next;
        n++;
    }

    if(p == NULL)
        return 0;
    else
        return n;
}


/*--------------------------在单链表L中第i个位置上插入元素e----------------------*/
int ListInsert(LinkList *&L, int i, ElemType e)
{
    int j = 0;
    LinkList *p = L, *s;

    while((j < i - 1) && (p != NULL))
    {
        j++;
        p = p->next;
    }

    if(p == NULL)                                   // 未找到第i-1个结点
        return 0;
    else                                            // 找到第i-1个结点
    {
        s = (LinkList *)malloc(sizeof(LinkList));   // 创建新结点
        s->data = e;
        s->next = p->next;                          // 将s插入到p之后
        p->next = s;
        return 1;
    }
}

/*--------------------在单链表L中删除第i个元素------------------------*/
int ListDelete(LinkList *&L, int i, ElemType &e)
{
    int j = 0;
    LinkList *p = L, *q;

    while((j < i - 1) && (p != NULL))
    {
        j++;
        p = p->next;
    }
    if(p == NULL)                                   // 未找到第i-1个结点
        return 0;
    else                                            // 找到第i-1个结点
    {
        q = p->next;                                // q指向要删除的结点
        if(q == NULL)                               // 不存在第i个结点
            return 0;
        e = q->data;
        p->next = q->next;                          // 从单链表中删除q结点
        free(q);
        return 1;
    }
}

int main()
{
    LinkList *h;
    ElemType e;

    printf("(1)初始化单链表h\n");
    InitList(h);
    printf("(2)依次采用尾插法插入a、b、c、d、e元素\n");
    ListInsert(h, 1, 'a');
    ListInsert(h, 2, 'b');
    ListInsert(h, 3, 'c');
    ListInsert(h, 4, 'd');
    ListInsert(h, 5, 'e');
    printf("(3)输出单链表h:");
    DispList(h);
    printf("(4)单链表h长度 = %d\n", ListLength(h));
    printf("(5)单链表h为%s\n", (ListEmpty(h) ? "空" : "非空"));
    GetElem(h, 3, e);
    printf("(6)单链表h的第3个元素 = %c\n", e);
    printf("(7)元素a的位置 = %d\n", LocateElem(h, 'a'));
    printf("(8)在第4个元素位置上插入f元素\n");
    ListInsert(h, 4, 'f');
    printf("(9)输出单链表h:");
    DispList(h);
    printf("(10)删除h的第三个元素\n");
    ListDelete(h, 3, e);
    printf("(11)输出单链表h:");
    DispList(h);
    printf("(12)释放单链表h\n");
    DestroyList(h);
	system("pause");
    return 0;
}

在这里插入图片描述

（2）

#include<stdio.h>
#include<stdlib.h>
typedef struct student
{
	int num;
}stu;
struct node
{
	stu data;
	struct node *next;
};
void Initlist(node *&head)//初始化链表  
{
	node *Head = (node *)malloc(sizeof(node));//头节点
	Head->data.num = 10;
	Head->next = NULL;
	head = Head;//head为头指针   初始时指向头节点
}
void addlist(node *&head)//插入新的节点  
{
	node *p;//定义结构体指针
	p = head;//p指向头节点的地址
	while (p->next != NULL)
		p = p->next;
	node *q = (node*)malloc(sizeof(node));//创建新节点
	//输入数据
	scanf("%d", &q->data.num);
	q->next = p->next;
	p->next = q;
	/*q->next = NULL;
	p->next = q;*/
	printf("增加成功!\n");
}
void deletelist(node *&head)//删除一个节点
{
	int n;
	if (head == NULL)
	{
		printf("链表为空\n");
	}
	node *p, *p1 = NULL;//定位要删除的结点
	p = head;
	printf("请输入你要删除的数据\n");
	scanf("%d", &n);
	while (p->data.num != n && p->next != NULL)//不是所要查找的结点  继续往下找
	{
		p1 = p;//保存当前结点的地址
		p = p->next;
	}
	if (p->data.num = n)
	{
		if (p == head)//删除的是头结点
		{
			head = p->next;
		}
		else
		{
			p1->next = p->next;
		}
		free(p);
		printf("删除成功\n");
	}
	else
	{
		printf("没有找到\n");
	}
}
void alterlist(node *&head)//修改链表
{
	int n; int n1;
	node *p;
	p = head;
	printf("请输入修改的数据\n");
	scanf("%d", &n);
	printf("请输入你修改后的数据\n");
	scanf("%d", &n1);
	while (p->data.num != n && p->next != NULL)
	{
		p = p->next;
	}
	if (p->data.num = n)
	{
		p->data.num = n1;
		printf("修改成功\n");
	}
	else
		printf("没有找到数据\n");
}
void printlist(node *&head)//输出链表
{
	node *p;
	p = head;
	while (p->next != NULL)
	{
		printf("%   d", p->data);
		p = p->next;
	}
	printf("%   d", p->data);
}
int listlength(node *&head)//  计算链表的长度
{
	int n = 0;
	node *p = head;
	while (p->next != NULL)
	{
		n++;
		p = p->next;
	}
	return n+1;
}
void nixu(node *&head)  //逆序输出链表
{
	node *p = head;
	node *p1 = head->next;
	node *p2=NULL;
	if (p == NULL || p1 == NULL)
		return;
	while (p1!= NULL)
	{
		p2= p1->next; //保存第二个节点的地址  防止丢失
		p1->next = p;
		p = p1;
		p1 = p2;   //  指针向后移
	
	}
	head->next=NULL;  //插入尾节点
	head=p;
}
int main()
{
	node *head = NULL;
	int number;
	Initlist(head);
	printf("请输入你要进行的操作\n");

	while (	scanf("%d", &number))
	{
		switch (number)
		{
		case 1:
			printf("增加一个数据\n");
			addlist(head);
			printlist(head);
			printf("\n");
			break;
		case 2:
			printf("删除一个数据\n");
			deletelist(head);
			printlist(head);
			printf("\n");
			break;
		case 3:
			printf("修改链表\n");
			alterlist(head);
			printlist(head);
			printf("\n");
			break;
		case 4:
			printf("输出链表\n");
			printlist(head);
			printf("\n");
			break;
		case 5:
			int n;
			printf("求链表的长度\n");
			printf("%d\n",listlength(head));
			break;
		case 6:
			printf("逆序输出链表\n");
			nixu(head);
			printlist(head);
			printf("\n");
			break;
		default:
			printf("请重新输入\n");
		}
	}
	system("pause");
	return 0;
}

在这里插入图片描述

三，实现双链表的各种基本运算的算法

#include <stdio.h>
#include <stdlib.h>

typedef char ElemType;
typedef struct DNode        // 定义双链表结点类型
{
	    ElemType data;          // 数据域
		    struct DNode *prior;    // 指向前驱结点
		    struct DNode *next;     // 指向后继结点
}DLinkList;


/*---------------------初始化双链表L------------------*/
void InitList(DLinkList *&L)
{
	    L = (DLinkList *)malloc(sizeof(DLinkList));         // 创建头结点
		    L->prior = L->next = NULL;
}

/*------------------释放双链表L------------------------*/
void DestroyList(DLinkList *&L)
{
	    DLinkList *p = L, *q = p->next;

	    while (q != NULL)
		    {
		        free(p);
		        p = q;
		        q = p->next;
		    }
	    free(p);
}

/*----------------------判断双链表L是否为空表------------------*/
int ListEmpty(DLinkList *L)
{
	    return (L->next == NULL);
}

/*----------------------返回双链表L的元素个数------------------*/
int ListLength(DLinkList *L)
{
	    int i = 0;
	    DLinkList *p = L;

	    while (p->next != NULL)
		    {
		        i++;
		        p = p->next;
		    }

	    return (i);
}

/*-----------------------输出双链表L-----------------------*/
void DispList(DLinkList *L)
{
	    DLinkList *p = L->next;

	    while (p != NULL)
		    {
		        printf("%c ", p->data);
		        p = p->next;
		    }
	    printf("\n");
}

/*-------------------获取双链表L中第i个元素-------------------*/
int GetElem(DLinkList *L, int i, ElemType &e)
{
	    int j = 0;
	    DLinkList *p = L;

	    while ((j < i) && (p != NULL))
		    {
		        j++;
		        p = p->next;
		    }

	    if (p == NULL)
		        return 0;
	    else
		    {
		        e = p->data;                // 提取数据元素
			        return 1;
		    }
}

/*-----------------------在双链表L中查找元素e---------------------*/
int LocateElem(DLinkList *L, ElemType e)
{
	    int n = 1;
	    DLinkList *p = L->next;

	    while ((p != NULL) && (p->data != e))
		    {
		        n++;
		        p = p->next;
		    }

	    if (p == NULL)
		        return 0;
	    else
		        return n;
}

/*--------------------在双链表L中第i个位置上插入元素e----------------------*/
int ListInsert(DLinkList *&L, int i, ElemType e)
{
	    int j = 0;
	    DLinkList *p = L, *s;

	    while ((j < i - 1) && (p != NULL))
		    {
		        j++;
		        p = p->next;
		    }
	    if (p == NULL)                       // 未找到第i-1个结点
		        return 0;
	    else                                // 找到第i-1个结点
		    {
		        s = (DLinkList *)malloc(sizeof(DLinkList));// 创建新结点s
		        s->data = e;
		        s->next = p->next;                          // 将s插入到p之后
			        if (p->next != NULL)
			            p->next->prior = s;
		        s->prior = p;
		        p->next = s;
		        return 1;
		    }
}

/*-----------------在双链表L中删除第i个元素----------------------*/
int ListDelete(DLinkList *&L, int i, ElemType &e)
{
	    int j = 0;
	    DLinkList *p = L, *q;

	    while ((j < i - 1) && (p != NULL))
		    {
		        j++;
		        p = p->next;
		    }
	    if (p == NULL)                           // 未找到第i-1个结点
		        return 0;
	    else                                    // 找到第i-1个结点
		    {
		        q = p->next;                        // q指向要删除的结点
			        if (q == NULL)                       // 不存在第i个结点
			            return 0;
		        e = q->data;
		        p->next = q->next;                  // 从链表中删除q结点
			        if (p->next != NULL)
			            p->next->prior = p;
		        free(q);                            // 释放q结点
			        return 1;
		    }
}

int main(void)
{

	    DLinkList *h;
	    ElemType e;

	    printf("(1)初始化双链表h\n");
	    InitList(h);

	    printf("(2)依次采用尾插法插入a、b、c、d、e元素\n");
	    ListInsert(h, 1, 'a');
	    ListInsert(h, 2, 'b');
	    ListInsert(h, 3, 'c');
	    ListInsert(h, 4, 'd');
	    ListInsert(h, 5, 'e');
	    printf("(3)输出双链表h:");
	    DispList(h);
	    printf("(4)双链表h长度 = %d\n", ListLength(h));
	    printf("(5)双链表h为%s\n", (ListEmpty(h)?   "空" : "非空"));
	    GetElem(h, 3, e);
	    printf("(6)双链表h的第3个元素 = %c\n", e);
	    printf("(7)元素a的位置 = %d\n", LocateElem(h, 'a'));
	    printf("(8)在第4个元素位置上插入f元素\n");
	    ListInsert(h, 4, 'f');
	    printf("(9)输出单链表h:");
	    DispList(h);
	    printf("(10)删除h的第三个元素\n");
	    ListDelete(h, 3, e);
	    printf("(11)输出双链表h:");
	    DispList(h);
	    printf("(12)释放双链表h\n");
	    DestroyList(h);
		system("pause");
	    return 0;
}

在这里插入图片描述

陌生人你好.
关注
专栏目录
数据结构实验C语言实现版
闭关修炼——暂退
01-16 1万+
目录 数据结构实验——顺序表的基本操作 数据结构实验——单链表的基本操作 数据结构实验——顺序栈的建立及基本操作实现 数据结构实验——链队列的建立及基本操作实现 数据结构实验——赫夫曼树构造及赫夫曼编码的实现 数据结构实验——迪杰斯特拉算法求最短路径 数据结构实验——顺序表的基本操作 /*-----顺序表的基本操作-----*/ #include<stdio.h> #include<stdlib.h> #define maxsize 1024 typedef cha
用C实现二叉树遍历算法（数据结构作业）
you2336的博客
06-09 145
#include<stdio.h> #include<stdlib.h> #define MaxSize 255 typedef char ElemType; typedef struct BiTNode { ElemType data; struct BiTNode *lchild, *rchild; } BiTNode, *BiTree; typedef struct { BiTree BNode[MaxSize]; int front, rear; } SqQue
我的----
热门推荐
zhuchunyan_aijia的博客
05-07 9万+
www
封锁阳光大学
Brute♂force
10-10 299
题目 https://www.luogu.org/problemnew/show/P1330 思路 很显然，用黑白染色。然后取黑白最小值 注意每个联通块都要更新一次 代码 #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cstring&gt; using namespace std; const int maxn=1e5+77...
16GB内存神奇玩法大全【@电脑报】
jixingzhong的专栏
09-09 3887
去年的内存价格还高高在上，为了节省预算很多消费者在配机时都只购买2GB内存，不过到了今年年初，内存的价格就开始有所松动，终于在五六月的时候，内存价格出现了比较明显的下滑，自此一泻千里……如今，单条4GB DDR3 1333内存的价格跌近100元，很多消费者在配机时都会直接选择两条
数据结构之线性表讲解，助力软件设计师考试
最新发布
08-11
数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试...
数据结构之线性表.rar
04-07
在本资料“数据结构之线性表.rar”中，我们将探讨如何使用C++实现线性表，并涵盖增、删、改、查等基本操作。 1. **线性表的概念**： 线性表的每个元素都有一个唯一的序号，称为位置或者索引。元素之间存在一对一的...
数据结构之线性表教程3.zip
01-02
在这个“数据结构之线性表教程3.zip”压缩包中，很可能是对线性表的深入讲解和实践应用的资源集合。 线性表是一种一维数组结构，其中的元素按照特定顺序排列。每个元素都有一个唯一的索引，通常从0或1开始。线性表...
数据结构之线性表的实现.rar
07-27
在这个压缩包“数据结构之线性表的实现.rar”中，我们可以找到关于线性表实现的详细内容，特别是针对严蔚敏版数据结构的实现。 线性表的常见实现方式有两种：顺序表和链表。在顺序表中，元素在内存中是连续存储的，...
数据结构之线性表的定义 定义线性表节点的结构.pdf
04-18
数据结构之线性表的定义和结构 数据结构是计算机科学中的一门重要学科，它研究的是数据的存储、组织和操作，旨在提高数据处理的效率和性能。在数据结构中，线性表是最基本和最重要的一种数据结构形式。本文将详细...
Drools实践与动态加载
MAI44的博客
08-18 969
Drools是一款基于Java的开源规则引擎，将规则与业务代码解耦。规则以脚本的形式存储在一个文件中，使规则的变化不需要修改代码，重新启动机器即可在线上环境中生效。规则引擎实现了业务决策从应用程序代码中分离出来，并使用预定义的语义模块编写业务决策。接受数据输入、解释业务规则，以及基于业务规则做出业务决策，从而提供极大的编程便利。
SynthWave '84 - VS Code theme小白安装教程
茄子大哥的博客
05-04 6875
出处 https://github.com/robb0wen/synthwave-vscode?from=singlemessage&isappinstalled=0 主题效果 安装过程其实和作者在github上上传的Installation是一样的，无非是做了一个排版，以及帮助看见英文就头疼的老哥们。 第一步 在Vscode市场里面安装 SynthWave '84基础主题包和自定义c...
STL 之 deque双向队列
sugarbliss
12-06 337
deque与vector一样也是顺序容器。它内部拥有更复杂的数据结构，从deque队列的两端插入和删除元素都非常快，在容器中间插入或删除则需要付出的代价非常高。 deque的绝大部分操作与vector一致，如支持各种构造方式，push_back，insert，size，resize，empty，capacity等各种vector所支持的操作。并支持push_front(),pop_front()...
使用Rust开发操作系统(可编程中断控制器(PIC)8259A)
VenmoSnake的博客
12-31 1593
8259A PIC可编程中断控制器(PIC)8259A PIC 可编程中断控制器(PIC) 中断的产生有两种原因,一个是外部中断(由硬件产生的中断),另一个是由指令int n产生的中断,指令int n中n位向量号(IDT中定义),外部中断有些复杂些,因为需要建立硬件中断和向量号之间的对应关系,外部中断分为不可屏蔽中断(NMI)和可屏蔽中断两种,分别由CPU的两根引脚NMI和INTR来接受,Inte...
Spark44-待续。。。
sz_bdqn的专栏
04-15 368
Spark44-待续。。。
JSP连接数据库（MySQL）
qq_44705939的博客
10-31 954
JSP链接数据库（MySQL） 最近在学JSP，记录一下关于JSP链接数据库的一些笔记。 首先通过两个JSP网页模拟一个验证查询的功能： 1.index.jsp（简单的一个验证表单）: <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTY...
HTTPS是什么？网站部署HTTPS的注意事项有哪些！
weixin_34375054的博客
03-28 451
什么是 HTTPS？ HTTPS（超文本传输安全协议）是一种互联网通信安全协议，它确保在用户的计算机与网站终端服务器之间传递的数据的完整性和机密性。所以，为了保护用户的隐私数据，国内信息安全服务商GDCA建议采用HTTPS来保护网站与用户之间的通讯。 HTTPS之所以是安全的通信协议，是因为在HTTP下加入SSL层（传输层安全协议SSL...
Spring Boot+MyBatis+Freemarker(ftl)增删改查
weixin_44914784的博客
04-14 1464
搭建项目所需要选择的东西 1.pom.xml所需jar包 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLoca...
div+css画一个小猪佩奇
单枪匹码
01-03 649
用DIV+CSS画一个小猪佩奇，挺可爱的，嘻嘻。 1、HTML部分：（全是DIV） <!-- 小猪佩奇整体容器 --> <div class="pig_container"> <!-- 尾巴 --> <div class="tail_left"></div> <div class="tail_right"&g...
数据结构之线性表详解：顺序表和链表
线性表是数据结构中的一种基本结构，指的是n（≥0）个数据元素的有限序列。线性表的特点是：同一线性表中元素具有相同特性；相邻数据元素之间存在序偶关系；除第一个元素外，其他每一个元素有一个且仅有一个直接前驱...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值