2.3 线性表的链式表示和实现（双向循环链表）

最新推荐文章于 2022-10-23 15:02:20 发布
最新推荐文章于 2022-10-23 15:02:20 发布
阅读量465 收藏
点赞数
分类专栏： 数据结构 C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaohaiguang/article/details/105842710
版权

盛年不重来，一日难再晨。及时宜自勉，岁月不待人。

                                                                                      ——陶渊明

目录

一、前言

二、双向循环链表图示

三、双链表的存储结构

四、常用操作的实现

1.头插法建立双向循环链      图示   代码      2.尾插法建立双向循环链表    图示    代码                                       3.查找结点     

4.获取链表长度                                           5.删除第i个结点     图示    代码       6.在第i个位置之前插入新结点    图示    代码

7.输出链表                                                  8.修改第i个结点的值                       9.销毁链表                               10.清空链表

五、源代码

六、总结

 

一、前言

学习了单链表，我们发现每个结点只能找到其后继结点，而不能找到前驱结点，我们可以思考能否再加一个指针域，使其能够访问其前驱结点，这就是双链表的由来。因此双向循环链表的意思就是一个结点有两个指针域，分别指向直接前驱结点和直接后继结点，并且尾结点指向头结点，这样的好处是什么呢？

好处就是可以直接访问某个结点的前驱结点，并且由任意一个结点出发均能找到表中所有结点。这在单链表中是不能实现的。应用在双向查询的场合，但双向循环链表的缺点就是占用内存大，而且操作稍微复杂。

二、双向循环链表图示

双向循环链表图示

三、双链表的存储结构

typedef struct DuLNode{
	int            data;
	struct DuLNode * prior;//前驱结点 
	struct DuLNode * next; //后继结点 
}DuLNode,* DuLinkList;

/*  最后一句的等同于下面代码，中括号是我自己加上的，只是提示把他们看作是一个整体
 
typedef  {struct  DuLNode   }  DuLNode;      // struct  DuLNode 的别名是 DuLNode
 
typedef  {struct  DuLNode * }  DuLinkList;   // struct  DuLNode *  的别名是 DuLinkList

*/

四、常用操作的实现

1.头插法建立双向循环链表

图示

头插法建立双向循环链表

代码


 //1.头插法建立线性表 
 Status create_headLinked_List(DuLinkList & L,int n) 
 //逆序输入n个元素的值，建立带表头结点双向循环链表L 
 {
 	DuLinkList head = (DuLinkList)malloc(sizeof(DuLNode));//头结点的存储地址 
 	if(NULL == head) return ERROR;                        //分配空间失败 
 	L = head;                                             //头指针L存储头结点P的地址，即头指针指向头结点 
 	L->data = 0; 					      //用头结点统计元素个数，刚开始为0个
	L->prior = L;                                	      //链表为空，头结点prior指向自己 
 	L->next  = L;                             	      //链表为空，头结点next指向自己  
 							      //由此得出链表为空条件: L->next == L->prior == L 
 	for(int i = 0;i<n;i++)
	 {
 		DuLinkList List_Node = (DuLinkList)malloc(sizeof(DuLNode));
 		if(NULL == List_Node) return ERROR;
 		scanf("%d",&List_Node->data);
 		L->data++;  
		List_Node->prior  = head;                         
 		List_Node->next   = head->next;
		head->next->prior = List_Node;                //头插法，即链表中的元素顺序与输入相反 
 		head->next = List_Node;
	 } 
	 return OK;
 }

2.尾插法建立双向循环链表

图示

  

代码

//2.尾插法创建带头结点的链表 
 Status tail_create_heahLinked_List(DuLinkList & L,int n) 
 {
 	DuLinkList head = (DuLinkList)malloc(sizeof(DuLNode));//头结点的存储地址 
 	if(NULL == head) return ERROR;                       
        L = head;                                             //头指针L存储头结点P的地址，即头指针指向头结点 
 	L->data = 0; 					      //用头结点统计元素个数，刚开始为0个
	L->prior = L;                                		  
 	L->next  = L;                             		      
	DuLinkList List_Node = NULL;                               
 	for(int i = 0;i<n;i++)
	 {
 		List_Node = (DuLinkList)malloc(sizeof(DuLNode));
 		if(NULL == List_Node) return ERROR;
 		scanf("%d",&List_Node->data);
 		L->data++;  
		List_Node->prior  = head->prior;
		List_Node->next   = head;               //每插入一个元素，头结点统计链表元素个数加一 
 		head->prior->next = List_Node;          //尾插法，即链表中的元素顺序与输入相同 
 		head->prior = List_Node;
	 } 
	 return OK;
 }

3.查找结点

 

//3.查找某一个数据是否在链表中，如果没有，返回false，否则返回该结点的位序
 
 Status  getDuLNodeIndex(DuLinkList L,int number)
 {
 	int i=1;
 	DuLinkList  temp =L->next;
 	while(temp != L ) 
	 {
 		if(number == temp->data) return i;
 		temp = temp->next;
 		i++;
	 }
	 return FALSE;
 }

 

4.获取链表长度

 //4.获取链表长度
 Status getLength(DuLinkList L)
 {
 	return L->data;
 }

 

5.删除第i个结点

图示

代码

//5.删除某个位置节点 （从1开始） 
 
 Status  deleteDuLNode(DuLinkList L ,int i,int & e)       //用e保存删除的节点 
 {
 	int j=1;
 	if(L->next == L && L->prior ==L )  return ERROR;  //表为空 
 	if(j > i || i>L->data)  return ERROR;             //说明位置不合理，直接返回 
 	DuLinkList temp = L;
	while(j<=i)
	{
		temp = temp->next;
		j++;
	} 
	e = temp->data; 
        temp->next->prior = temp->prior;
	temp->prior->next = temp->next; 
	free(temp);
	L->data--;
	return OK;
 }

6.在第i个位置之前插入新结点

图示

代码

//6.在第i个位置之前插入新结点
Status  insertDuLNode(DuLinkList L ,int i,int value)
{
	int j=1;
	if( j > i || i>L->data + 1 )   return ERROR;//允许在最后一个元素之后插入元素 
	DuLinkList temp = L;
	DuLinkList newDuLNode = (DuLinkList)malloc(sizeof(DuLNode));
	while(j<i)
	{
		temp = temp->next;
		j++;
	}
	newDuLNode->data  = value;
	newDuLNode->next  = temp->next;
	newDuLNode->prior = temp;
	temp->next->prior = newDuLNode;
	temp->next = newDuLNode;
	L->data++;
	return OK;
}

7.输出链表

//7.输出带头结点链表中的元素 
 void headlinked_List_Traverse(DuLinkList  L)
 {
 	
    printf("该链表的元素个数为：%d \n",L->data);
	DuLinkList p = L->next;    
 	while(p != L)
	{    
 	    printf(" %d ",p->data);	
		p = p->next;	    	
	}
 	
}

 

8.修改第i个结点的值

//8.修改第i个结点的值

Status  updateDuLNode(DuLinkList L,int i,int value)
{
	int j=1;
 	if(L->next == L && L->prior ==L )  return ERROR;//表为空 
 	if(j > i || i>L->data)  return ERROR;           //说明位置不合理，直接返回 
	DuLinkList temp = L;
	while(j<=i )
	{
		temp = temp->next;
		j++;
	}  
        temp->data = value; 
	return OK;
}

9.销毁链表

//销毁链表,包括头结点的所有结点全部释放	 
Status destroy_headlinked_list(DuLinkList & L)	
{
	L->data = 0; 
	DuLinkList p = NULL;
	while(L)
	{   
	    p = L->next;
	    free(L);
	    L = p;			    	
	} 
        L = NULL;
 	return OK;
}

 

10.清空链表

Status clear_headlinked_list(DuLinkList  L)	
{
	L->data = 0; 
	DuLinkList p,q;
	p = q = L->next;
	while(p != L)
	{   
	    q = p->next;
	    free(p);
	    p = q;			    	
	} 
	L->next = L->prior = L;
 	return OK;
 
}

 

五、源代码

#include<cstdio>
#include<cstdlib>
#include<malloc.h>
#include<cstring>
#include<conio.h>
//函数结果状态代码 
#define TRUE  1
#define FALSE 0
#define OK    1
#define ERROR 0 

typedef int Status;  //int 的别名，其值是函数结果状态代码 

typedef struct DuLNode{
	int            data;
	struct DuLNode * prior;//前一个结点 
	struct DuLNode * next; //后一个结点 
}DuLNode,* DuLinkList;

/*  最后一句的等同于下面代码，中括号是我自己加上的，只是提示把他们看作是一个整体
 
typedef  {struct  DuLNode   }  DuLNode;      // struct  DuLNode 的别名是 DuLNode
 
typedef  {struct  DuLNode * }  DuLinkList;   // struct  DuLNode *  的别名是 DuLinkList

*/


 //1.建立线性表 
 Status create_headLinked_List(DuLinkList & L,int n) 
 //逆序输入n个元素的值，建立带表头结点双向循环链表L 
 {
 	DuLinkList head = (DuLinkList)malloc(sizeof(DuLNode));//头结点的存储地址 
 	if(NULL == head) return ERROR;                        //分配空间失败 
 	L = head;                                       	  //头指针L存储头结点P的地址，即头指针指向头结点 
 	L->data = 0; 										  //用头结点统计元素个数，刚开始为0个
	L->prior = L;                                		  //链表为空，头结点prior指向自己 
 	L->next  = L;                             		      //链表为空，头结点next指向自己  
 													      //由此得出链表为空条件: L->next == L->prior == L 
 	
	head->next = head;									
 	head->prior = head;
	 for(int i = 0;i<n;i++)
	 {
 		DuLinkList List_Node = (DuLinkList)malloc(sizeof(DuLNode));
 		if(NULL == List_Node) return ERROR;
 		scanf("%d",&List_Node->data);
 		L->data++;  
		List_Node->prior  = head;                         
 		List_Node->next   = head->next;
		head->next->prior = List_Node;                    //头插法，即链表中的元素顺序与输入相反 
 		head->next = List_Node;
	 } 
	 return OK;
 }
 
 //2.尾插法创建带头结点的链表 
 Status tail_create_heahLinked_List(DuLinkList & L,int n) 
 {
 	DuLinkList head = (DuLinkList)malloc(sizeof(DuLNode));//头结点的存储地址 
 	if(NULL == head) return ERROR;                       
    L = head;                                       	  //头指针L存储头结点P的地址，即头指针指向头结点 
 	L->data = 0; 										  //用头结点统计元素个数，刚开始为0个
	L->prior = L;                                		  
 	L->next  = L;                             		      
	DuLinkList List_Node = NULL;                               
 	for(int i = 0;i<n;i++)
	 {
 		List_Node = (DuLinkList)malloc(sizeof(DuLNode));
 		if(NULL == List_Node) return ERROR;
 		scanf("%d",&List_Node->data);
 		L->data++;  
		List_Node->prior  = head->prior;
		List_Node->next   = head;               //每插入一个元素，头结点统计链表元素个数加一 
 		head->prior->next = List_Node;               //尾插法，即链表中的元素顺序与输入相同 
 		head->prior = List_Node;
	 } 
	 return OK;
 }
 
 
 //3.查找某一个数据是否在链表中，如果没有，返回false，否则返回该结点的位序
 
 Status  getDuLNodeIndex(DuLinkList L,int number)
 {
 	int i=1;
 	DuLinkList  temp =L->next;
 	while(temp != L ) 
	 {
 		if(number == temp->data) return i;
 		temp = temp->next;
 		i++;
	 }
	 return FALSE;
 }
 
 //4.获取链表长度
 Status getLength(DuLinkList L)
 {
 	return L->data;
 } 
 
 //5.删除某个位置节点 （从1开始） 
 
 Status  deleteDuLNode(DuLinkList L ,int i,int & e)//用e保存删除的节点 
 {
 	int j=1;
 	if(L->next == L && L->prior ==L )  return ERROR;//表为空 
 	if(j > i || i>L->data)  return ERROR;//说明位置不合理，直接返回 
 	DuLinkList temp = L;
	while(j<=i)
	{
		temp = temp->next;
		j++;
	} 
	e = temp->data; 
    temp->next->prior = temp->prior;
	temp->prior->next = temp->next; 
	free(temp);
	L->data--;
	return OK;
 } 
 

  
//6.在第i个位置之前插入新结点
Status  insertDuLNode(DuLinkList L ,int i,int value)
{
	int j=1;
	if( j > i || i>L->data + 1 )   return ERROR;//允许在最后一个元素之后插入元素 
	DuLinkList temp = L;
	DuLinkList newDuLNode = (DuLinkList)malloc(sizeof(DuLNode));
	while(j<i)
	{
		temp = temp->next;
		j++;
	}
	newDuLNode->data  = value;
	newDuLNode->next  = temp->next;
	newDuLNode->prior = temp;
	temp->next->prior = newDuLNode;
	temp->next = newDuLNode;
	L->data++;
	return OK;
} 



 //7.输出带头结点链表中的元素 
 void headlinked_List_Traverse(DuLinkList  L)
 {
 	
    printf("该链表的元素个数为：%d \n",L->data);
	DuLinkList p = L->next;    
 	while(p != L)
	{    
 	    printf(" %d ",p->data);	
		p = p->next;	    	
	}
 	
}

//8.修改第i个结点的值

Status  updateDuLNode(DuLinkList L,int i,int value)
{
	int j=1;
 	if(L->next == L && L->prior ==L )  return ERROR;//表为空 
 	if(j > i || i>L->data)  return ERROR;//说明位置不合理，直接返回 
	DuLinkList temp = L;
	while(j<=i )
	{
		temp = temp->next;
		j++;
	}  
    temp->data = value; //结点
	return OK;
} 

//输出不带头结点链表中的元素 
 void linkedListTraverse(DuLinkList  L)
 {
	DuLinkList p = L;    
 	while(p)
	{    
 	    printf(" %d ",p->data);	
		p = p->next;	    	
	}
 	
}

/*清空链表跟销毁链表的区别 ... 销毁：是先销毁了链表的头，然后接着一个一个的把后面的销毁了，
这样这个链表就不能再使用了，即把包括头的所有节点全部释放。 清空：是先保留了链表的头，
然后把头后面的所有的都销毁，最后把头里指向下一个的指针设为空，
这样就相当与清空了，但这个链表还在，还可以继续使用；即保留了头，后面的全部释放。*/
//销毁链表,包括头结点的所有结点全部释放	 
Status destroy_headlinked_list(DuLinkList & L)	
{
	L->data = 0; 
	DuLinkList p = NULL;
	while(p != L)
	{   
	    p = L->next;
	    free(L);
	    L = p;			    	
	} 
    L = NULL;
 	return OK;
}

/*清空带头结点链表
  1.先保留链表的头结点
  2.然后把头结点后面的所有的都销毁
  3.最后把头结点里指向首元结点的指针设为空 */
Status clear_headlinked_list(DuLinkList  L)	
{
	L->data = 0; 
	DuLinkList p,q;
	p = q = L->next;
	while(p != L)
	{   
	    q = p->next;
	    free(q);
		p = q;			    	
	} 
	L->next = L->prior = L;
 	return OK;
 
}  


//销毁不带头结点的链表 

Status destroy_linked_list(DuLinkList  L)
{
	DuLinkList p;
	while(L)
	{
		p = L->next;
		free(L);
		L = p;
	}
	return OK;
}

int main(void)
{
	DuLinkList L;//头指针L 
	int n = 0;
	printf("请输入所要创建带头结点链表的元素个数：");
	scanf("%d",&n);
	
	printf("\n\n请输入所要创建带头结点链表的元素数据：");
	//if(create_headLinked_List( L, n) )     //头插法 
	if( tail_create_heahLinked_List( L, n) ) //尾插法 
		headlinked_List_Traverse(L);
	int number=0;
	printf("\n请输入查找的元素：");
	scanf("%d",&number);
	if(getDuLNodeIndex(L,number))	
    	printf("%d",getDuLNodeIndex(L, number));
    else printf("未找到！ ");
    
    printf("\n该链表的长度为：%d",getLength(L));

    int i=1,value,e;
    printf("\n请输入删除结点的位置：");
	scanf("%d",&i); 
    if(deleteDuLNode( L ,i,e))   
		printf("\n删除结点%d成功\n",e);
    else    
		printf("\n删除结点%d失败\n",e);
    
    headlinked_List_Traverse(L);
    printf("\n该链表的长度为：%d",getLength(L));
     
    printf("\n请输入插入结点的位置和数据：");
    scanf("%d %d",&i,&value); 
    insertDuLNode( L ,i, value);
    printf("\n该链表的长度为：%d",getLength(L));
    headlinked_List_Traverse(L);
    
    printf("\n请输入待修改结点的位置和数据：");
    scanf("%d %d",&i,&value); 	
	updateDuLNode(L,i, value);
	headlinked_List_Traverse(L);
	
	if(destroy_headlinked_list(L))
		printf("\n销毁带头结点链表L成功!\n");
	else printf("销毁失败！！\n"); 

	
	return 0;
}

六、总结

 

1.理解双向循环链表的关键就是理清链表的首尾关系，即临界点，另外就是要勤加练习双向思考，多实践

2.每插入或者删除一个结点时，都要考虑前驱后继的关系

3.双向循环链表可以做链表的逆序输出、双向查找等等，有着很多的优点，代价就是多了一个指针域

 

少年与云眠
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表定义与实现
02-19
线性表的类型定义 2.2 线性表的顺序表示和实现 2.3 线性表的链式表示和实现 2.3.1 线性链表 2.3.2 循环链表 2.3.3 双向链表 2.4 一元多项式的表示及相加
【数据结构】线性表3——线性表的链式表示和实现（循环链表和双向链表）
FishC的博客
10-15 172
【数据结构】线性表3——线性表的链式表示和实现（循环链表和双向链表）
[数据结构] [C语言] 线性表的链式表示和实现——循环链表、双向链表
__Zhou__的博客
09-02 379
循环链表 循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。 判断空链表的条件 head == head->next; rear == rear->next; 应用 在链表上实现将两个线性表（a1，a2，…，an）和（b1，b2，…，bm）连接成一个线性表（a1，…，an，b1，…bm）的运算。 分析：若在单链表或头指针表示的单循环...
第二章：4.线性表---循环链表和双向链表
12-15 131
前言： 　　循环链表：是另一种形式的链式存储结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成了一个环。因此，从表中任意节点出发均可找到表中的其他结点。 　　 　　双向链表：前讨论的链式存储结构中个，每个结点都只有一个指示其后继元素的指针域，那么找下一个元素（NextElem） 的时间复杂度 为 O(1)。但是寻找直接前继元素必须要从头结点开始找，PriorElem ...
线性表的链式表示和实现----双向循环链表
烽火前秦路
03-31 739
头文件 head.h #include #include #include /* malloc()等 */ #include /* INT_MAX等 */ #include /* EOF(=^Z或F6),NULL */ #include /* atoi() */ #include /* eof() */ #include /* floor(),ceil(),abs() */ #inc
C语言单、双、线性、循环链表及实例
热门推荐
qq_41853417的博客
03-11 2万+
C语言 链表 实例
精心整理史上最全的数据结构flash演示动画，共5个版本，祝大家考研成功！
03-10
\数据结构flash演示\版本2\2.3 线性表的链式表示和实现-双向循环链表中左边插入节点.swf \数据结构flash演示\版本2\2.3 线性表的链式表示和实现-表头插入节点.swf \数据结构flash演示\版本2\2.3 线性表的链式表示...
严蔚敏数据结构C语言版教材讲义
10-27
C语言基础 1.1 什么是数据结构 1.2 基本概念和术语 1.3 抽象数据类型的表示与实现 1.4 算法和算法分 ...2.3 线性表的链式表示和实现 2.3.1 线性链表 2.3.2 循环链表 2.3.3 双向链表 2.4 一元多项式的表示及相加
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
1.4 C＋＋程序的编写和实现 1.5 关于C＋＋上机实践 习题 第2章 数据类型与表达式 2.1 C＋＋的数据类型 2.2 常量 2.2.1 什么是常量 2.2.2 数值常量 2.2.3 字符常量 2.2.4 符号常量 2.3 变量 2.3.1 什么是变量 2.3.2 ...
玩转数据结构之双向循环链表
一个人工智能专业的编程赶路人
08-29 619
链表一直是数据结构中十分重要的一部分，此文章主要对其中的双向循环链表进行拆解
双向循环链表的使用
04-12
该程序包括双向循环链表的建立，查找，删除，添加等功能，可以根据自己的需要完成特定的功能
线性表的应用 —— 双向链表 && 循环链表
谢谢你们的关注
09-12 413
线性表的应用 —— 双向链表 && 循环链表
6-3 循环双链表插入操作
qq_61369552的博客
10-23 710
循环双链表的删除
带头结点的双向循环链表/创建/删除/插入/查找
凭澜偏偏
07-24 2402
什么是双向循环链表 1、拥有两个指针域prior以及next，一个数据域data 2、尾部的next指针 指向头结点 存储结构 typedef struct DuLNode { ElemType data; struct DuLNode *prior; struct DuLNode *next; }DuLNode,*DuLinklist; 带头结点双链循环表创建 1、创建头结点 2、在循环...
《数据结构》双向链表的创建
千言万语ROOM
03-03 1121
双向链表的创建 双向链表的创建同样像单链表一样可以有两种方法：头插法和尾插法。 使用尾插法创建双向链表： 算法思想： 先定义一个指针q指向头结点 1.新结点p的前驱指向头结点L; 2.新结点的next指针域置空； 3.头结点的next指向p； 4.q指向p. void CreateList1(DuLinkList &L,int n){ L=new DuLNode; L->ne
【C++】双向链表
Sunny的博客
03-05 1135
逆序建立一个双向链表，该链表从第二个结点至表尾递增有序，将第一个结点删除并插入到适当位置，使整个链表仍然递增有序。
数据结构 第4-2讲 双向链表
rainchxy的博客
11-21 1548
数据结构 第4-2讲 双向链表 链表是线性表的链式存储方式，逻辑上相邻的数据在计算机内的存储位置不一定相邻，那么怎么表示逻辑上的相邻关系呢？ 可以给每个元素附加一个指针域，指向下一个元素的存储位置。这种链表称为单向链表，简称单链表，如图1所示： 图1 单链表 单链表中每个结点除了存储自身数据之后，还存储了下一个结点的地址，因此可以轻松访问下一
双向循环链表（prior）的修复
w_nxsxs的博客
11-28 2357
【问题描述】 假设一个双向循环链表，其结点含有三个域：prior,data和next。其中data为数据域；prior指向前驱结点，next指向后继结点。创建链表时，只链接了next域，导致链表只是一个单向循环链表。请补充算法，修复双向链表，可以实现双向访问。 【输入形式】 第1行输入n，表示输入n个数据。 第2行输入n个整数，创建循环链表。（只创建了单向） 【输出形式】 从头到尾输出链表元素； 从尾到头输出链表元素； 【样例输入】 5 1 2 3 4 5 【样例输出】 1 2 3
1.1 数组逆置（C语言实现）
蓝天的博客
04-13 1万+
数组是一种常见的容器，本次我们练习一下数组逆置问题。 在解决问题之前，我们第一步是要明确问题是什么，然后思考解决问题的方法，最后写代码进行实现 第一步：分析问题，找到解决问题的思路 由上图可以分析，数组逆置需要将中心点两边的元素进行交换。 那么这又延伸出两个问题，如何选取中心点？如何交换两个元素？ 第二步：选取中心点 一个数组的元素个数 n 要么是奇数，要么是偶数，这里我们分情况...
线性表的链式表示和实现c++
最新发布
11-13
线性表是一种常见的数据结构，它包含了一组有序的元素，元素之间具有前驱和后继关系。线性表的链式表示是其中一种实现方式。...在C语言中，可以通过定义节点结构体和指针来实现链式表示，实现链表的各种操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值