数据结构-链表

最新推荐文章于 2020-10-21 14:56:41 发布
最新推荐文章于 2020-10-21 14:56:41 发布
阅读量457 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fzubbsc/article/details/29253523
版权

前些天在看《算法精解-C语言描述》一书时，发现书里面的用于实现各种数据结构的源代码写的很精练，但是有苦于找不到该书的书本源代码，所以就干脆敲出来，发布到博客里，希望以后用到的时候直接拿来用。本博客只用于学习用途。若有侵权，请及时联系我，我马上删除。在此我就不再赘述各种数据结构的概念了，直接贴上源代码

1、单链表实现源代码

/*dlist.h*/

#ifndef DLIST_H
#define DLIST_H

#include <stdlib.h>

/*Define a structure for double-linked list elements 链表元素结构*/
typedef struct DListElmt_
{
	void *data;             //数据域
	struct DListElmt_ *prev; //前驱指针
	struct DListElmt_ *next; //后继指针

} DListElmt;

/*Define a struture for double-linked lists 双向链表结构*/
typedef struct DList_
{
	int size;
	int (*match)(const void *key1,const void *key2);
	void (*destroy)(void *data);
	DListElmt *head;
	DListElmt *tail;
} DList;

/*public interface*/
void dlist_init(DList *list,void (*destroy)(void *data));
void dlist_destroy(DList *list);
int dlist_ins_prev(DList *list,DListElmt *element,const void *data);
int dlist_ins_next(DList *list,DListElmt *element,const void *data);
int dlist_remove(DList *list,DListElmt *element,void **data);

#define dlist_size(list)  ((list)->size)
#define dlist_head(list)  ((list)->head)
#define dlist_tail(list)  ((list)->tail)
#define dlist_is_head(list,element)  ((element)==(list)->head ? 1:0)
#define dlist_is_tail(element)  ((element)==(list)->tail ? 1:0)
#define dlist_data(element)  ((element)->data)
#define dlist_prev(element)  ((element)->prev)
#define dlist_next(element)  ((element)->next)


#endif

/*list.c*/
/***********************************************************************************
** File name:list.c       
** Functions Descriptions: 
	void list_init():initialize the list
	void list_destroy():destroy the list
	int list_ins_next():insert the *data to the list behind the *element
	list_rem_next():remove the element behind the *element 

************************************************************************************/

#include<stdlib.h>
#include<stdio.h>
#include<memory.h>
#include "list.h"


void list_init(List *list,void (*destroy)(void *data))
{  
	/*initialize the list*/
	list->size=0;
	list->destroy=destroy;
	list->head=NULL;
	list->tail=NULL;
	return ;
}


void list_destroy(List *list)
{
	void *data;
	while(list_size(list)>0)
	{
		if(list_rem_next(list,NULL,(void **)&data)==0 && list->destroy!=NULL)
		{ list->destroy(data);    }
	}
	memset(list,0,sizeof(List));
	return ;
}


int list_ins_next(List *list,ListElmt *element,const void *data)
{
	ListElmt *new_element;
	if((new_element=(ListElmt *)malloc(sizeof(ListElmt)))==NULL)
		return -1;
	/*insert the element into the list*/
	new_element->data=(void *)data;
	if(element==NULL)
	{  /*Handle insertion at the head of the list*/
		if(list_size(list)==0)
			list->tail=new_element;

		new_element->next=list->head;
		list->head=new_element;
	}
	else
	{ /*handle insertion somewhere*/
		if(element->next==NULL)
			list->tail=new_element;

		new_element->next=element->next;
		element->next=new_element;
	}

	list->size++;
	return 0;

}


int list_rem_next(List *list,ListElmt *element,void **data)
{
	ListElmt *old_element;
	if(list_size(list)==0)
		return -1;
	/*remove element for list*/
	if(element==NULL)
	{
		/*handle removal from the head*/
		*data=list->head->data;
		old_element=list->head;
		list->head=list->head->next;

		if(list_size(list)==1)
			list->tail=NULL;
	}
	else
	{
		/*handle removal from somewhere*/
		if(element->next==NULL)
			return -1;
		*data=element->next->data;
		old_element=element->next;
		element->next=element->next->next;

		if(element->next==NULL)
			list->tail=NULL;
	}
	free(old_element);
	list->size--;
	return 0;

}

应用实例：
<pre class="cpp" name="code">/*main.c*/
#include<stdio.h>
#include"list.h"
#include"dlist.h"
#include"clist.h"
#include<memory.h>
#include<string.h>

typedef struct Student_
{
	char name;
	char sex;
	int age;

}Student;

int List_printf(List *list)
{
	int flag=1;
	char name,sex;
	int age;
	ListElmt *listelmt=list->head;
	
	while(flag==1)
	{
		Student *stu=listelmt->data;
	    name=stu->name;
		sex=stu->sex;
		age=stu->age;
		printf("name is %c,sex is %c,age is %d\n",name,sex,age);
		if(listelmt==list->tail)
			flag=0;
		listelmt=listelmt->next;
	}
	return 1;
}

int stu_init(Student *student,char names,char sexs,int ages)
{
	student->name=names;
	student->sex=sexs;
	student->age=ages;
	return 1;
}



int main()
{   /*init three student*/
	int count;
	List *plstu=(List *)malloc(sizeof(List));
	Student *stu1=(Student *)malloc(sizeof(Student));
	Student *stu2=(Student *)malloc(sizeof(Student));
	Student *stu3=(Student *)malloc(sizeof(Student));
	stu_init(stu1,'A','M',23);
	stu_init(stu2,'B','F',22);
	stu_init(stu3,'C','M',24);

	list_init(plstu,(void *)list_destroy);
    list_ins_next(plstu,NULL,stu1);
	list_ins_next(plstu,list_tail(plstu),stu2);
	list_ins_next(plstu,list_tail(plstu),stu3);
	count=list_size(plstu);
	printf("the size of the list is %d\n",count);
	List_printf(plstu);




	return 1;
}




 2、双向链表实现源代码 

/*dlist.h*/

#ifndef DLIST_H
#define DLIST_H

#include <stdlib.h>

/*Define a structure for double-linked list elements 链表元素结构*/
typedef struct DListElmt_
{
	void *data;             //数据域
	struct DListElmt_ *prev; //前驱指针
	struct DListElmt_ *next; //后继指针

} DListElmt;

/*Define a struture for double-linked lists 双向链表结构*/
typedef struct DList_
{
	int size;
	int (*match)(const void *key1,const void *key2);
	void (*destroy)(void *data);
	DListElmt *head;
	DListElmt *tail;
} DList;

/*public interface*/
void dlist_init(DList *list,void (*destroy)(void *data));
void dlist_destroy(DList *list);
int dlist_ins_prev(DList *list,DListElmt *element,const void *data);
int dlist_ins_next(DList *list,DListElmt *element,const void *data);
int dlist_remove(DList *list,DListElmt *element,void **data);

#define dlist_size(list)  ((list)->size)
#define dlist_head(list)  ((list)->head)
#define dlist_tail(list)  ((list)->tail)
#define dlist_is_head(list,element)  ((element)==(list)->head ? 1:0)
#define dlist_is_tail(element)  ((element)==(list)->tail ? 1:0)
#define dlist_data(element)  ((element)->data)
#define dlist_prev(element)  ((element)->prev)
#define dlist_next(element)  ((element)->next)


#endif
 

 

/*dlist.c*/
#include<stdlib.h>
#include<stdio.h>
#include<memory.h>
#include "dlist.h"

/*dlist_init*/
void dlist_init(DList *list,void (*destroy)(void *data))
{  /*initialize the dlist*/

	list->size=0;
	list->destroy=destroy;
	list->head=NULL;
	list->tail=NULL;

	return ;
}

/*dlist_destroy*/
void dlist_destroy(DList *list)
{
	void *data;
	/*remove each element*/
	while(dlist_size(list)>0)
	{
		if(dlist_remove(list,dlist_tail(list),(void **)&data)==0 && list->destroy!=NULL)
		{ list->destroy(data);    }
	}
	memset(list,0,sizeof(DList));
	return ;
}

/*dlist_ins_prev*/
int dlist_ins_prev(DList *list,DListElmt *element,const void *data)
{
	DListElmt *new_element;
	/*Do not allow a NULL element unless the list is empty*/
	if(element==NULL && dlist_size(list)!=0)
		return -1;

	/*Allocate storage for the element*/
	if((new_element=(DListElmt *)malloc(sizeof(DListElmt)))==NULL)
		return -1;
	/*insert the element into the list*/
	new_element->data=(void *)data;
    
	if(dlist_size(list)==0)
	{
		/* handle insertion when the list is empty*/
		list->head=new_element;
		list->head->prev=NULL;
		list->head->next=NULL;
		list->tail=new_element;		
	}
	else
	{
		/*handle insertion when the list is not empty*/
		new_element->next=element;
		new_element->prev=element->prev;
		if(element->prev==NULL)
			list->head=new_element;
		else
			element->prev->next=new_element;
		element->prev=new_element;
	}

	list->size++;
	return 0;

}


/*dlist_ins_next*/
int dlist_ins_next(DList *list,DListElmt *element,const void *data)
{
	DListElmt *new_element;
	/*Do not allow a NULL element unless the list is empty*/
	if(element==NULL && dlist_size(list)!=0)
		return -1;

	/*Allocate storage for the element*/
	if((new_element=(DListElmt *)malloc(sizeof(DListElmt)))==NULL)
		return -1;
	/*insert the element into the list*/
	new_element->data=(void *)data;
    
	if(dlist_size(list)==0)
	{
		/* handle insertion when the list is empty*/
		list->head=new_element;
		list->head->prev=NULL;
		list->head->next=NULL;
		list->tail=new_element;		
	}
	else
	{
		/*handle insertion when the list is not empty*/
		new_element->next=element->next;
		new_element->prev=element;
		if(element->next==NULL)
			list->tail=new_element;
		else
			element->next->prev=new_element;
		element->next=new_element;
	}

	list->size++;
	return 0;

}



/*dlist_remove*/
int dlist_remove(DList *list,DListElmt *element,void **data)
{
 
	if(element==NULL ||dlist_size(list)==0)
		return -1;
	/*remove element for list*/
	*data=element->data;

	if(element==list->head)
	{
		/*handle removal from the head*/
		list->head=element->next;
		if(list->head==NULL)
			list->tail=NULL;
		else
			element->next->prev=NULL;
	}
	else
	{
		/*handle removal from somewhere*/
		element->prev->next=element->next;
		if(element->next==NULL)
			list->tail=element->prev;
		else
			element->next->prev=element->prev;
	}
	free(element);
	list->size--;
	return 0;

}


 

 


 3、循环链表实现源代码
 

/*clist.h*/

#ifndef CLIST_H
#define CLIST_H

#include <stdlib.h>

/*Define a structure for circular list elements 链表元素结构*/
typedef struct CListElmt_
{
	void *data;             //数据域
	struct CListElmt_ *next; //指针域
} CListElmt;

/*Define a struture for circular lists 单向循环链表结构*/
typedef struct CList_
{
	int size;
	int (*match)(const void *key1,const void *key2);
	void (*destroy)(void *data);
	CListElmt *head;

} CList;

/*public interface*/
void clist_init(CList *list,void (*destroy)(void *data));
void clist_destroy(CList *list);
int clist_ins_next(CList *list,CListElmt *element,const void *data);
int clist_rem_next(CList *list,CListElmt *element,void **data);

#define clist_size(list)  ((list)->size)
#define clist_head(list)  ((list)->head)
#define clist_is_head(list,element)  ((element)==(list)->head ? 1:0)
#define clist_data(element)  ((element)->data)
#define clist_next(element)  ((element)->next)


#endif
 

 
 

<pre class="cpp" name="code">/*clist.c*/
#include<stdlib.h>
#include<stdio.h>
#include<memory.h>
#include "clist.h"


/*clist_init*/
void clist_init(CList *list,void (*destroy)(void *data))
{  /*initialize the list*/

	list->size=0;
	list->destroy=destroy;
	list->head=NULL;

	return ;
}

/*clist_destroy*/
void clist_destroy(CList *list)
{
	void *data;
	/*remove each element*/
	while(clist_size(list)>0)
	{
		if(clist_rem_next(list,list->head,(void **)&data)==0 && list->destroy!=NULL)
		{ list->destroy(data);    }
	}
	memset(list,0,sizeof(CList));
	return ;
}

/*clist_ins_next*/
int clist_ins_next(CList *list,CListElmt *element,const void *data)
{
	CListElmt *new_element;
	/*Allocate storage for the element*/
	if((new_element=(CListElmt *)malloc(sizeof(CListElmt)))==NULL)
		return -1;
	/*insert the element into the list*/
	new_element->data=(void *)data;
	if(clist_size(list)==0)
	{  /*Handle insertion when the list is emtpy*/
	
		new_element->next=new_element;
		element->next=new_element;
	}
	else
	{ /*handle insertion when the list is no emtpy*/
	
		new_element->next=element->next;
		element->next=new_element;
	}

	list->size++;
	return 0;

}

/*clist_rem_next*/
int clist_rem_next(CList *list,CListElmt *element,void **data)
{
	CListElmt *old_element;

	/*do not allow removal from an empty list*/
	if(clist_size(list)==0)
		return -1;
	*data=element->next->data;
	if(element->next==element)
	{
		/*handle only one element*/
		old_element=element->next;
		list->head=NULL;

	}
	else 
	{
		/*handle removing other than one element*/
		old_element=element->next;
		element->next=element->next->next;
		if(old_element==clist_head(list)) //last element
			list->head=old_element->next;
	}

	free(old_element);
	list->size--;
	return 0;

}
 

 


                

        

        

    




    

      

        

            

              
                
                  fzubbsc之雕虫小技
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
算法精解----3、单链表

				
			

			

				

					张勇1234的博客
				

				

					08-01
					
					241
					
				

			

		

		

			
				
1、链表需要动态开辟存储空间，链表元素连接在一起，但在内存空间中它们是分散开的。2、单链表只能以一个方向进行遍历3、释放的是data指向的内存，而不是分配给指针变量data本身的内存空间int *data;
data = (int*)malloc(sizeof(int));
free(data);4、single_list.h#ifndef SINGLE_LIST_H
#define SINGLE_

			
		

	



                

              
                



	

		

			

				
					
算法和数据结构总结---单链表

				
			

			

				

					Kroner的博客
				

				

					11-22
					
					586
					
				

			

		

		

			
				
链表
链表可以说是一种很基本的数据结构，链表通常以一种特定的组合将元素链接在一起，以便可以对元素实现方便的管理维护。这一点和我们常常使用的数组很相似，但是链表在最多的情况下可以带来比链表更为优势的操作，链表通常是在系统需要的时候动态开辟的，换句话说链表的存储空间是在程序运行的时候在进行分配的，在许多的时候，我们无法明确的确定数据的大小直接在编译前分配内存，这种动态分配的方法也是链表的优势之一。
单...

			
		

	



                


  
              

                


	

		

			

				
					
算法精解（五）：哈希表

				
			

			

				

					qq_32579021的博客
				

				

					02-25
					
					233
					
				

			

		

		

			
				
1.个人理解

关于哈希表，通过看书与资料，有了一些自己的理解。

我更喜欢将哈希表比作是一个二维数组void chtbl[type][N]

同一数据类型的数据存储在一个一维数组里面，type表示不同类型的数据类型。

比如圆形，方形，心形，六边形代表四种类型的框，如果一个物体数据某种类型，

则将该物体放入对应的框中。而N则代表相应数据类型的个数，

而如何辨别该物体是什么形状，则需要一套方法...

			
		

	





	

		

			

				
					
链表的C语言实现

				
			

			

				

					Jamza的博客
				

				

					07-18
					
					478
					
				

			

		

		

			
				
链表
链表由一组元素，以一种特定的顺序组合或者链接在一起
相对数组，链表在执行插入、删除操作时具有更高的效率
链表需要动态的开辟存储空间，也就是存储空间在程序运行时是动态分配的
链表类型：单向链表、双向链表、循环链表
单向链表
list_init
void list_init(List *list, void (*destroy)(void *data));
/*
初始化由参数list指定的链表
参数destroy为函数指针，提供了一种释放动态分配数据的方法
*/

list_destroy
void li

			
		

	



		

			
		



	

		

			

				
					
链表（2）----双链表基本操作

				
			

			

				

					录事参军
				

				

					12-09
					
					1648
					
				

			

		

		

			
				
双链表的基本操作

			
		

	





	

		

			

				
					
链表（1）----单链表基本操作

				
			

			

				

					录事参军
				

				

					12-09
					
					2172
					
				

			

		

		

			
				
1、单链表定义


单链表元素定义：
typedef  struct ListElement_t_{
    void  *data;
    struct ListElement_t_  *next;
} ListElement_t;

单链表定义：
typedef struct List_t_{
    int  size;
    int  (*match)(const void

			
		

	





	

		

			

				
					
C Tips: 比较函数 int(*cmp)(const void *, const void *)

				
			

			

				

					辛亚平的专栏
				

				

					04-05
					
					8527
					
				

			

		

		

			
				
C语言中，一个通用的比较函数的指针，可以表示为：

			
		

	





	

		

			

				
					
C 算法精介----链表（1）

				
			

			

				

					编程语言小筑
				

				

					12-14
					
					111
					
				

			

		

		

			
				

 C算法 ---链表

 链表是一种最为基础的数据结构，链表是由一组元素以一种特定的顺序组合或链接在一起的。在维护数据的集合时很有用途。在平时的数据处理过程中经常会会用链接进行数据的临时存储。但是如何才能使链表处理数据更加优化，下面简单介绍单链表处理情况！
1 、单链表介绍
 单链表是各个元素之间通过一个指针彼此连接起来而组成的。元素可以分为2个部分：数据成员和一个称为nest的指针。通过...

			
		

	





	

		

			

				
					
算法精解_C语言 链表_单链表(接口定义+类型实现)

				
			

			

				

					idreamo的博客
				

				

					10-30
					
					848
					
				

			

		

		

			
				
链表可以说是一种最为基础的数据结构。链表由一组元素以一种特定的顺序组合或链接而成，在维护数据的集合时很有用。这一点同我们常用的数组很相似。然而，链表在很多情况下比数组更有优势。特别是在执行插入和删除操作时链表拥有更高的效率。链表需要动态的开辟存储空间，也就是存储空间是在程序运行时分配的。由于在很多应用中数据的大小在编译时并不能确定，因此这种动态分配空间的特性也是链表的一个优点。

			
		

	





	

		

			

				
					
数据结构-链表.pdf

					
最新发布

				
			

			

				

					04-15
				

			

		

		

			
				
数据结构-链表 单向链表，双向链表、循环链表等

			
		

	





	

		

			

				
					
C语言数据结构-链表版学生管理系统

				
			

			

				

					10-02
				

			

		

		

			
				
源码+可运行exe程序

			
		

	





	

		

			

				
					
数据结构-链表的C语言使用

				
			

			

				

					03-25
				

			

		

		

			
				
数据结构-链表的用法，单链表，带头节点链表，循环链表等，C语言code

			
		

	





	

		

			

				
					
第11章 动态数据结构-链表-21

				
			

			

				

					08-03
				

			

		

		

			
				
第11章 动态数据结构的C语言实现单向链表-2int power;struct node *next;建立一个单向链表1 创建节点：2 链：使每个节点的指针域存

			
		

	





	

		

			

				
					
数据结构-链表相关功能和算法

				
			

			

				

					06-11
				

			

		

		

			
				
数据结构-链表相关功能和算法

			
		

	





	

		

			

				
					
数据结构-链表(LingkedList)介绍和Java示例代码

				
			

			

				

					07-01
				

			

		

		

			
				
介绍数据结构链表(LingkedList)的概念、特点、优缺点、适用场景和Java示例代码

			
		

	





	

		

			

				
					
C实现通用数据结构--单链表

				
			

			

				

					weixin_33847182的博客
				

				

					10-22
					
					153
					
				

			

		

		

			
				
单链表概述
单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。

从概念上讲，可以把链表想象成一系列连续的元素，然而，由于这些元素是动态分配的（C语言中使用malloc），切记这些元素通常实际上都是分散在内存空间的
欢迎关注我的个人博客：www.wuyudong.com, 更多精彩文章与您分享
单链表的接口定义：
1、list_ini...

			
		

	





	

		

			

				
					
数据结构之栈

				
			

			

				

					花道
				

				

					11-30
					
					278
					
				

			

		

		

			
				
决定采用何种方式来存储数据是非常重要的，这样便于检索数据时，数据会自动按照某种规定的顺序给出。
栈是检索数据的一种方式，它检索元素的顺序与存储元素的顺序相反。
栈：先进后出。
要把元素存储到栈中，就“压入”元素，要删除栈中的元素，就“弹出”元素。
有时候，可以通过检查栈顶的元素（而不是实际去删除它）来获取元素的某些信息。


实现栈的方式有很多，这里采用链表来实现。因为栈本身就是个链

			
		

	





	

		

			

				
					
数据结构 链表_单链表的接口定义

				
			

			

				

					weixin_30613433的博客
				

				

					11-17
					
					113
					
				

			

		

		

			
				
链表可以说是一种最为基础的数据结构。链表由一组元素以一种特定的顺序组合或链接而成，在维护数据的集合时很有用。这一点同我们常用的数组很相似。然而，链表在很多情况下比数组更有优势。特别是在执行插入和删除操作时链表拥有更高的效率。链表需要动态的开辟存储空间，也就是存储空间是在程序运行时分配的。由于在很多应用中数据的大小在编译时并不能确定，因此这种动态分配空间的特性也是链表的一个优点。
单链表介绍
单...

			
		

	





	

		

			

				
					
数据结构之单链表、双向链表和循环链表

				
			

			

				

					DayDayUp
				

				

					10-21
					
					1385
					
				

			

		

		

			
				
链表是一种最为基础的数据结构，



			
		

	





	

		

			

				
					
数据结构----单向链表

				
			

			

				

					03-27
				

			

		

		

			
				
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点只知道下一个节点的位置，而不知道前一个节点的位置。  单向链表的特点是插入和删除操作的效率较高，...

			
		

	



              



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

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值