数据结构之树和二叉树

最新推荐文章于 2024-09-12 18:02:13 发布
最新推荐文章于 2024-09-12 18:02:13 发布
阅读量241 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 二叉树 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44161383/article/details/103627866
版权

十一，实现二叉树的各种基本运算的方法

在这里插入图片描述

#include<stdio.h>
#include<stdlib.h>
#define ElemType char
#define max 100
typedef struct node
{
	ElemType data;
	struct node *lchild;  //左孩子 
	struct node *rchild;  //右孩子 
}BTNode;

void CreateTree(BTNode *&b, char *str)		//创建二叉树 
{
	BTNode *st[max];	//st数组作为顺序栈	
	BTNode *p;
	int top = -1, k, j = 0;
	char ch;
	b = NULL;
	ch = str[j];
	while (ch != '\0')
	{
		switch (ch)
		{
			case '(':top++; st[top] = p; k = 1; break;
			case ')':top--; break;
			case ',':k = 2; break;
			default:
			{
					   p = (BTNode *)malloc(sizeof(BTNode));
					   p->data = ch;
					   p->lchild = NULL; p->rchild = NULL;
					   if (b == NULL)
						   b = p;
					   else
					   {
						   switch (k)
						   {
						   case 1:st[top]->lchild = p; break;
						   case 2:st[top]->rchild = p; break;
						   }
					   }
			}
				
		}
		j++;
		ch = str[j];
	}
}

void destorytree(BTNode *&b)			//销毁二叉树 
{
	if (b != NULL)
	{
		destorytree(b->lchild);
		destorytree(b->rchild);
		free(b);
		b = NULL;
	}
	//ClearBiTree();
}
 void ClearBiTree(BTNode *T)			//清空 
{
    if(T == NULL)
        return;
    ClearBiTree(T->lchild);
    ClearBiTree(T->rchild);
    free(T);
}
BTNode *findnode(BTNode *b, ElemType e)			//查找结点 
{
	BTNode *p;
	if (b == NULL)
		return 0;
	else if (b->data == e)
		return b;
	else
	{
		p = findnode(b->lchild, e);
		if (p != NULL)
		{
			return p;
		}
		else
			return findnode(b->rchild, e);

	}
}

BTNode *Lchildnode(BTNode *p)		//找左孩子节点 
{
	return p->lchild;
}
BTNode *Rchildnode(BTNode *p)		//找右孩子节点 
{
	return p->rchild;
}


int height(BTNode *b)	        	//求高度 
{
	int lh, rh;
	if (b == NULL)
		return 0;
	else
	{
		lh = height(b->lchild);
		rh = height(b->rchild);
		return(lh>rh) ? (lh+1 ): (rh+1);
	}
}

void disptree(BTNode *b)
{
	if (b != NULL)
	{
		printf("%c", b->data);
		if (b->lchild != NULL || b->rchild != NULL)
		{
			printf("(");
			disptree(b->lchild);
			if (b->rchild != NULL)
				printf(",");
			disptree(b->rchild);
			printf(")");
			
		}
	}

}
int main()
{
	char c[100] = "A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))";
	BTNode *b,*x,*y;
	CreateTree(b, c);
	printf("输出二叉树为：\n");
	disptree(b);
	printf("\n\nH的左节点为：\n");
	x=Lchildnode(findnode(b,'H'));
	disptree(x);
	printf("\n\n右节点为:\n");
	y=Rchildnode(findnode(b,'H'));
	disptree(y);
	printf("\n\n二叉树的高度为：%d",height(b));
	printf("\n");
	destorytree(b);ClearBiTree(b);
	if(b==NULL)
		printf("释放成功\n");
	system("pause");		
	return 0;
}

在这里插入图片描述

十二，实现二叉树的各种遍历算法

在这里插入图片描述

#include<stdio.h>
#include<stdlib.h>
#define ElemType char
#define max 100
typedef struct node
{
	ElemType data;
	struct node *lchild;  //左孩子 
	struct node *rchild;  //右孩子 
}BTNode;
typedef struct
{
	BTNode * data[max];
	int front, rear;
}SqQueue;

void CreateTree(BTNode *&b, char *str)		//创建二叉树 
{
	BTNode *st[max];	//st数组作为顺序栈
		BTNode *p;
	int top = -1, k, j = 0;
	char ch;
	b = NULL;
	ch = str[j];
	while (ch != '\0')
	{
		switch (ch)
		{
		case '(':top++; st[top] = p; k = 1; break;
		case ')':top--; break;
		case ',':k = 2; break;
		default:
		{
				   p = (BTNode *)malloc(sizeof(BTNode));
				   p->data = ch;
				   p->lchild = NULL; p->rchild = NULL;
				   if (b == NULL)
					   b = p;
				   else
				   {
					   switch (k)
					   {
					   case 1:st[top]->lchild = p; break;
					   case 2:st[top]->rchild = p; break;
					   }
				   }
		}

		}
		j++;
		ch = str[j];
	}
}


void destorytree(BTNode *&b)			//销毁二叉树 
{
	if (b != NULL)
	{
		destorytree(b->lchild);
		destorytree(b->rchild);
		free(b);
		b = NULL;
	}
	//ClearBiTree();
}
void ClearBiTree(BTNode *T)			//清空二叉树 
{
	if (T == NULL)
		return;
	ClearBiTree(T->lchild);
	ClearBiTree(T->rchild);
	free(T);
}

void disptree(BTNode *b)		//输出二叉树 
{
	if (b != NULL)
	{
		printf("%c", b->data);
		if (b->lchild != NULL || b->rchild != NULL)
		{
			printf("(");
			disptree(b->lchild);
			if (b->rchild != NULL)
				printf(",");
			disptree(b->rchild);
			printf(")");

		}
	}

}

void Preorder(BTNode *b)      //先序遍历递归算法(跟   左  右)
{
	if (b != NULL)
	{
		printf("%4c", b->data);
		Preorder(b->lchild);
		Preorder(b->rchild);
	}
}
void Inorder(BTNode *b)      //中序遍历递归算法(左  跟   右)
{
	if (b != NULL)
	{
		Inorder(b->lchild);
		printf("%4c", b->data);
		Inorder(b->rchild);
	}
}
void Postorder(BTNode *b)      //后序遍历递归算法(左  右   跟)
{
	if (b != NULL)
	{

		Postorder(b->lchild);
		Postorder(b->rchild);
		printf("%4c", b->data);
	}
}
void InitQueue(SqQueue *&q)
{
	q = (SqQueue *)malloc(sizeof(SqQueue));
	q->front = q->rear = 0;
}
void DestroyQueue(SqQueue *&q)
{
	free(q);
}
bool emptyQueue(SqQueue *q)
{
	return(q->front == q->rear);
}
//进队列
bool enQueue(SqQueue * &q,BTNode * &b)
{
	if(q->rear==max-1)
	{				
		return false;					
	}
	q->rear++;							
	q->data[q->rear]=b;				
	return true;							
}

//出队列 
bool deQueue(SqQueue * &q,BTNode * &b)
{
	if(q->front==q->rear)
	{				 
		return false;					
	}
	q->front++;							
	b=q->data[q->front];			
	return true;					
}


void levelOrder(BTNode * &b)		//层次遍历 
{
	SqQueue *q;								
	InitQueue(q);							
	if(b!=NULL)
	{
		enQueue(q,b);						
	} 
	while(emptyQueue(q)!=true)
	{				
		deQueue(q,b);						
		printf("%4c",b->data);				
		if(b->lchild!=NULL)
		{				
			enQueue(q,b->lchild);
		}
		if(b->rchild!=NULL)
		{				
			enQueue(q,b->rchild);
		}									
	} 											
}



int main()
{
	int n;
	char c[100] = "A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))";
	BTNode *b;
	CreateTree(b, c);
	printf("输出二叉树为：\n");
	disptree(b);
	printf("\n输入你要进行的操作\n1.    先序排列\n2.    中序排列\n3.    后序排列\n4.    层次排列\n");
	while (scanf("%d", &n))
	{

		switch (n)
		{
		case 1:
			Preorder(b);
			printf("\n");
			break;
		case 2:
			Inorder(b);	printf("\n");
			break;

		case 3:
			Postorder(b); printf("\n");
			break;
		case 4:levelOrder(b); printf("\n");
			break;

		}
	}
	destorytree(b); ClearBiTree(b);
	if (b == NULL)
		printf("释放成功\n");
	system("pause");
	return 0;
}

在这里插入图片描述

十三，由遍历序列构造二叉树

在这里插入图片描述

#include<stdio.h> 
#include<stdlib.h>
#define ElemType char
#define max 100
typedef struct node
{
	ElemType data;
	struct node *lchild;  //左孩子 
	struct node *rchild;  //右孩子 
}BTNode;

void CreateTree(BTNode *&b, char *str)		//创建二叉树 
{
	BTNode *st[max];	//st数组作为顺序栈	
	BTNode *p;
	int top = -1, k, j = 0;
	char ch;
	b = NULL;
	ch = str[j];
	while (ch != '\0')
	{
		switch (ch)
		{
			case '(':top++; st[top] = p; k = 1; break;
			case ')':top--; break;
			case ',':k = 2; break;
			default:
			{
					   p = (BTNode *)malloc(sizeof(BTNode));
					   p->data = ch;
					   p->lchild = NULL; p->rchild = NULL;
					   if (b == NULL)
						   b = p;
					   else
					   {
						   switch (k)
						   {
						   case 1:st[top]->lchild = p; break;
						   case 2:st[top]->rchild = p; break;
						   }
					   }
			}
				
		}
		j++;
		ch = str[j];
	}
}


void destorytree(BTNode *&b)			//销毁二叉树 
{
	if (b != NULL)
	{
		destorytree(b->lchild);
		destorytree(b->rchild);
		free(b);
		b = NULL;
	}
	//ClearBiTree();
}
 void ClearBiTree(BTNode *T)			//清空二叉树 
{
    if(T == NULL)
        return;
    ClearBiTree(T->lchild);
    ClearBiTree(T->rchild);
    free(T);
}

void disptree(BTNode *b)		//输出二叉树 
{
	if (b != NULL)
	{
		printf("%c", b->data);
		if (b->lchild != NULL || b->rchild != NULL)
		{
			printf("(");
			disptree(b->lchild);
			if (b->rchild != NULL)
				printf(",");
			disptree(b->rchild);
			printf(")");
		}
	}

}

BTNode *CreateBT1(char *pre,char *in,int n)   		//先序和中序
{
	BTNode *b;
	char *p;
	int k;
	if(n<=0)
	return NULL;
	b=(BTNode *)malloc(sizeof(BTNode));
	b->data=*pre;
	for(p=in;p<in+n;p++)
	{
		if(*p==*pre)
			break;
	}
		k=p-in;
		b->lchild=CreateBT1(pre+1,in,k);
		b->rchild=CreateBT1(pre+k+1,p+1,n-k-1);
		return b;
	
}
BTNode * CreateBT2( char * post, char * in, int n )
{
	BTNode	* b;
	char	r, *p;
	int	k;
	if ( n <= 0 )
		return(NULL);
	r	= *(post + n - 1);
	b	= (BTNode *) malloc( sizeof(BTNode) );
	b->data = r;
	for ( p = in; p < in + n; p++ )
		if ( *p == r )
			break;
	k		= p - in;
	b->lchild	= CreateBT2( post, in, k );
	b->rchild	= CreateBT2( post + k, p + 1, n - k - 1 );
	return(b);
}

int main()
{
	int n;
	char c1[100]="ABDEHJKLMNCFGI";
	char c2[100]="DBJHLKMNEAFCGI";
	char c3[100]="DJLNMKHEBFIGCA";
	BTNode *b;
	BTNode *x;
	
	printf("\n输入你要进行的操作\n1.   先序和中序输出\n2.   中序和后序输出\n");
	while(scanf("%d",&n))
	{
		switch(n)
		{
			case 1:	
					b=CreateBT1(c1,c2,14);
					printf("先序为：%s\n",c1);
					printf("中序为：%s\n",c2);
					printf("输出二叉树为：\n");
					disptree(b);
					printf("\n");
					break;
			case 2:
					{
		
					printf("中序为：%s\n",c2);
					printf("后序为：%s\n",c3);
					x=CreateBT2(c3,c2,14);
					printf("输出二叉树为：\n");
					disptree(x);
					printf("\n");
					break;
				}
		
		}
	}
	destorytree(b);ClearBiTree(b);
	if(b==NULL)
		printf("释放成功\n");
	system("pause");
	return 0;
}

在这里插入图片描述

十四，构造哈夫曼树和生成哈夫曼编码

在这里插入图片描述

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

#define N (50)      // 树中叶子结点数最大值
#define M (2 * N - 1) // 树中结点总数最大值

typedef struct
{
	   char data[5]; // 结点值
	   int weight; // 权重
	   int parent; // 双亲结点
	   int lchild; // 左孩子结点
	   int rchild; // 右孩子结点
}HTNode; // 声明哈夫曼树结点类型

typedef struct
{
	   char cd[N]; // 存放哈夫曼编码
	   int start;
}HCode; // 声明哈夫曼编码类型

/*-------------由含有n个叶子结点的ht构造完整的哈夫曼树-----------------*/
void create_huffman_tree(HTNode ht[], int n)
{
	   int i;
	   int k;
	   int lnode;
	   int rnode;
	   int min1;
	   int min2;

	   // 所有结点的相关域设置初值为-1
		   for (i = 0; i < 2 * n - 1; i++)
		      ht[i].parent = ht[i].lchild = ht[i].rchild = -1;
	   for (i = n; i < 2 * n - 1; i++) // 构造哈夫曼树的分支结点
		   {
		      min1 = min2 = 32767;
		      lnode = rnode = -1;
		      for (k = 0; k <= i - 1; k++) // 查找最小和次小的结点
			      {
			         if (ht[k].parent == -1) // 只在尚未构造二叉树的结点中查找
				         {
				            if (ht[k].weight < min1)
					            {
					               min2 = min1;
					               rnode = lnode;
					               min1 = ht[k].weight;
					               lnode = k;
					            }
				            else if (ht[k].weight < min2)
					            {
					               min2 = ht[k].weight;
					               rnode = k;
					            }
				         }
			      }
		      ht[lnode].parent = i; // 合并两个最小和次小的结点
		      ht[rnode].parent = i;
		      ht[i].weight = ht[lnode].weight + ht[rnode].weight; // 计算双亲结点的权重
		      ht[i].lchild = lnode; // 设置双亲结点的左孩子
		      ht[i].rchild = rnode; // 设置双亲结点的右孩子
		   }
}

/*-------------由哈夫曼树ht构造哈夫曼编码hcd-----------------*/
void create_huffman_code(HTNode ht[], HCode hcd[], int n)
{
	   int i;
	   int f;
	   int c;
	   HCode hc;

	   for (i = 0; i < n; i++) // 根据哈夫曼树构造所有叶子结点的哈夫曼编码
		   {
		      hc.start = n;
		      c = i;
		      f = ht[i].parent;
		      while (f != -1) // 循环直到树根结点
			      {
			         if (ht[f].lchild == c) // 处理左孩子结点
				            hc.cd[hc.start--] = '0';
			         else // 处理右孩子结点
				            hc.cd[hc.start--] = '1';
			         c = f;
			         f = ht[f].parent;
			      }
		      hc.start++; // start指向哈夫曼编码最开始字符
		      hcd[i] = hc;
		   }
}

/*-------------输出哈夫曼编码-----------------*/
void display_huffman_code(HTNode ht[], HCode hcd[], int n)
{
	   int i;
	   int k;
	   int sum = 0;
	   int m = 0;
	   int j;

	   printf("输出哈夫曼编码:\n");
	   for (i = 0; i < n; i++)
		   {
		      j = 0;
		      printf("    %s:\t", ht[i].data);
		      for (k = hcd[i].start; k <= n; k++)
			      {
			         printf("%c", hcd[i].cd[k]);
			         j++;
			      }
		      m += ht[i].weight;
		      sum += ht[i].weight * j;
		      printf("\n");
		   }

	   printf("\n平均长度 = %g\n", 1.0 * sum / m);
}

int main()
{
	   int n = 15;
	   int i;
	   HTNode ht[M];
	   HCode hcd[N];
	   char *str[] = { "The", "of", "a", "to", "and", "in", "that", "he", "is", "at", "on", "for", "His", "are", "be" };
	   int fnum[] = { 1192, 677, 541, 518, 462, 450, 242, 195, 190, 181, 174, 157, 138, 124, 123 };

	   for (i = 0; i < n; i++)
		   {
		      strcpy(ht[i].data, str[i]);
		      ht[i].weight = fnum[i];
		   }
	   create_huffman_tree(ht, n); // 创建哈夫曼树
	   create_huffman_code(ht, hcd, n); // 构造哈夫曼编码
	   display_huffman_code(ht, hcd, n); // 输出哈夫曼编码
	   
	   system("pause");
	   return 0;
}

在这里插入图片描述

陌生人你好.
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
编写算法求二叉树结点x的双亲
weixin_45999886的博客
10-29 1049
【代码】编写算法求二叉树结点x的双亲。
数据结构--二叉树--双亲、孩子和兄弟节点的查询（顺序结构）
热门推荐
复兴之路
08-10 1万+
#include /* EOF(=^Z或F6),NULL */ #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ #if CHAR typedef char TElemType; TElemType
数据结构-二叉树（通过先序和中序或者是中序和后序得到二叉树）
代码屋-CODE HOUSE
04-13 1062
先序序列：ABDEHJKLMNCFGI中序序列：DBJHLKMNEAFCGI后序序列：DJLNMKHEBFIGCA#include &lt;iostream&gt; #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; #include&lt;string.h&gt; using namespace std; typedef struct node { ...
用二叉树排序树的作用c语言,C语言数据结构之二叉树排序
weixin_39866487的博客
05-16 489
一、定义与性质定义二叉排序树(Binary Sort Tree)又称二叉查找(搜索)树(Binary Search Tree)。其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树：①若它的左子树非空，则左子树上所有结点的值均小于根结点的值；②若它的右子树非空，则右子树上所有结点的值均大于根结点的值；③左、右子树本身又各是一棵二叉排序树。上述性质简称二叉排序树性质(BST性质)，故二叉排序树...
数据结构之树和二叉树(ppt 92页).pptx
09-22
【数据结构之树和二叉树】是计算机科学中重要的基础知识，主要研究树形数据结构的定义、特性和操作。本部分重点讲解了树和二叉树的基本概念、术语、性质以及相关的操作。 首先，**树的定义**是数据结构中的核心概念...
数据结构之树和二叉树.pptx
10-04
数据结构中的树是一种非常...总结来说，树和二叉树是数据结构中的基础部分，它们提供了对复杂数据组织的有效抽象。理解和掌握这些概念对于解决计算机科学中的许多问题，如文件系统、编译器设计、网络路由等都至关重要。
二叉树相关算法
Bright的博客
11-19 173
void CreateTree(BTNode* &amp;b, char str[]) { int i = 0; BTNode *tstack[MaxSize], *bb; int top = -1; int k = 0; while (str[i]) { switch (str[i]) { case '(': tstack[++top] = bb; i++; k = 1...
实验3 | 由遍历序列构造二叉树
月雲之霄的博客
08-25 4176
二叉树构造定理： 定理7.1：任何n（n&gt;0）个不同结点的二又树，都可由它的中序序列和先序序列唯一地确定。   定理7.2：任何n（n＞0）个不同结点的二又树，都可由它的中序序列和后序序列唯一地确定。 1.1 已知先序序列为ABDGCEF，中序序列为DGBAECF，则构造二叉树的过程如下所示。  1.1.1 C代码： #include&lt;stdio.h&gt; #inclu...
二叉树：编写一个函数int Depth(BiTNode *T)。函数功能：计算二叉树的深度。
刘珂的博客
10-08 2185
#include <stdio.h> #include <malloc.h> typedef struct BiTNode { int data; //关键字项 struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode; BiTNode...
数据结构 关于树的几个证明题及代码实现
奋进的小白粥
02-21 2377
一、求二叉树的深度typedef struct BTNode BTNode{ Elemtype data; struct BTNode *lchild,*rchild; } BTNode; int depth(BTNode *T){ if(!T) return 0; int ldepth = depth(T-&gt;lchild); int rdepth = depth(T-&...
编写一个程序exp5-3.cpp，实现由先序序列和中序序列构造一颗二叉树的功能。通过输入先序序列“ABDEHJKLMNCFGI”和中序序列“DBJHLKMNEAFCGI”构造一个二叉树，并打印输出该二
xx7755223的博客
10-19 1871
编写一个程序exp5-3.cpp，实现由先序序列和中序序列构造一颗二叉树的功能。通过输入先序序列“ABDEHJKLMNCFGI”和中序序列“DBJHLKMNEAFCGI”构造一个二叉树，并打印输出该二叉树。 btree同第一个 https://blog.csdn.net/xx7755223/article/details/109133739?utm_source=app exp5-3.cpp ...
数据结构算法——排序算法
qq_73643693的博客
09-07 791
数据结构中的常见算法——排序算法
【算法】冒泡排序
最新发布
想写博客却不会写，那能怎么办？抓紧练习咯！
09-12 127
冒泡排序是一种简单的排序算法，基本思想是通过重复遍历待排序的数列，比较相邻元素并交换它们的位置，以将较大（较小）的元素 “冒泡” 到数列的末端。最好的情况：O(n) ，此时说明我们的数据已经处于一个有序的状态。1、稳定性：即相等的元素在排序后仍保持原有的顺序性。2、简单：实先简单，易理解，不易使用在大型数据中。最坏和平均的情况：O(n的2次方)四、java代码示例。
数据结构之数组矩阵存储
zhj2003_的博客
09-12 169
数组在编程中是十分常用的一种数据结构，以后遇到的许多算法都会有它的身影，比如KMP算法定义next数组、其随机存取的特点可以用来排序、动态规划等问题。上述内容如果有错误的地方，希望大佬们可以指正。我一直在学习的路上，您的帮助使我收获更大！我也会不断更新文章！
数据结构之红黑树的 “奥秘“
robin_suli的博客
09-09 953
红黑树在经常进行增删的结构中性能比 AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。红黑树不追求绝对平衡，其只需保 证最长路径不超过最短路径的2倍(相对平衡)每个结点上增加一个存储位表示结点的颜色。红黑树和AVL树都是高效的平衡二叉树。没有一条路径会比其他路径长出俩倍。先grandParent右旋。围绕红黑树上面的几条性质。
【华为OD】2024D卷——生成哈夫曼树
weixin_45653183的博客
09-12 855
这是通过构建一种特殊的二叉树来实现的，其中每个字符都位于树的一个叶节点上，且该叶节点到根节点的路径上的边所代表的字符（在哈夫曼编码中通常使用0和1表示）共同构成了该字符的编码。·新节点作为这两个子节点的父节点，而原来的两个节点则成为新节点的左右子节点（通常约定左子节点频率小于等于右子节点）。2、不断从堆中取出两个最小的节点作为左右子树，构造一个新的父节点，其权值为两个节点权值之和，并将新节点插入堆中。·然后，算法反复地选择两个频率最小的节点，将它们合并为一个新的节点，新节点的频率是两个子节点频率之和。
数据结构深入讲解：树与二叉树
树和二叉树是数据结构中非常重要的概念，它们在计算机科学中有广泛的应用。本课件主要讲解了树的基本概念、存储结构、遍历方法以及二叉树的相关知识。 首先，树作为一种非线性的数据结构，能够有效表示具有分支和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值