二叉树详解（C语言版）

已于 2022-04-26 21:58:53 修改
阅读量9.7k 收藏 138
点赞数 20
分类专栏： 数据结构与算法 文章标签： 数据结构
于 2021-04-09 16:04:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44075108/article/details/115551237
版权

文章目录

一、定义

        二叉树是n (n≥0）个结点的有限集合：
        （1）、或者为空二叉树，即n = 0。
        （2）、或者由一个根结点和两个互不相交的被称为根的左子树和右子树组成。左子树和右子树又分别是一棵二叉树。

在这里插入图片描述

二、结构

结构示意图：

在这里插入图片描述
代码表示：

#define ElemType char //结点内数据的类型
//结点结构
typedef struct BinTreeNode
{
	ElemType data;  //数据域
	struct BinTreeNode *leftChild; //左孩子
	struct BinTreeNode *rightChild; //右孩子
}BinTreeNode;
//根结点管理
typedef struct BinTree
{
	BinTreeNode *root;//根结点
	ElemType     refvalue; //stop flag 停止的标记（用来设置停止的记号）
}BinTree;

三、常用操作

初始化

//二叉树初始化
void InitBinTree(BinTree *bt, ElemType ref)
{
	bt->root = NULL;//根设置为空
	bt->refvalue = ref; //设置停止标记
}

创建

        方式一

//方式一：使用二级指针
//供外部调用
void CreateBinTree_1(BinTree *bt)
{
	CreateBinTree_1(bt,&(bt->root));
}
//内部实现
void CreateBinTree_1(BinTree *bt, BinTreeNode **t)
{
	ElemType Item; //接收数据
	scanf("%c",&Item);
	if(Item == bt->refvalue) //判断输入是否为一个结束标记
		(*t) = NULL;//是 说明这棵二叉树是空树
	else
	{//否
		//创建树（子树）根结点
		(*t) = (BinTreeNode*)malloc(sizeof(BinTreeNode));
		assert((*t) != NULL);
		(*t)->data = Item;//为结点赋值
		CreateBinTree_1(bt,&((*t)->leftChild)); //创建左子树
		CreateBinTree_1(bt,&((*t)->rightChild)); //创建右子树
	}
}

        方式二

//方式二：使用指针引用方式
//对外调用
void CreateBinTree_2(BinTree *bt)
{
	CreateBinTree_2(bt,bt->root);
}
//内部实现
void CreateBinTree_2(BinTree *bt, BinTreeNode *&t)
{
	ElemType Item;//接收数据
	scanf("%c",&Item);
	if(Item == bt->refvalue)//判断输入是否为一个结束标记
		t = NULL;//是 说明这棵二叉树是空树
	else
	{//否
		//创建树（子树）根结点
		t = (BinTreeNode*)malloc(sizeof(BinTreeNode));
		assert(t != NULL);
		t->data = Item;//为结点赋值
		CreateBinTree_2(bt,t->leftChild); //创建左子树
		CreateBinTree_2(bt,t->rightChild); //创建右子树
	}
}

        方式三

//方式三：通过返回值返回二叉树
void CreateBinTree_3(BinTree *bt)
{
	bt->root = CreateBinTree_3_(bt);
}
BinTreeNode* CreateBinTree_3_(BinTree *bt)
{
	ElemType Item; //接收数据
	scanf("%c",&Item);
	if(Item == bt->refvalue) //判断输入是否为一个结束标记
		return NULL;//是 说明这棵二叉树是空树
	else
	{//否
		//创建树（子树）根结点
		BinTreeNode *t = (BinTreeNode*)malloc(sizeof(BinTreeNode));
		assert(t != NULL);
		t->data = Item;//为结点赋值
		t->leftChild = CreateBinTree_3_(bt);//创建左子树
		t->rightChild = CreateBinTree_3_(bt);//创建右子树
		return t;//返回所创建的树
	}
}

        方式四

//方式4：传入要创建的二叉树的串进行创建
void CreateBinTree_4(BinTree *bt, char *str)
{
	CreateBinTree_4(bt,bt->root,str);
}
void CreateBinTree_4(BinTree *bt, BinTreeNode *&t, char *&str)
{
	if(*str == bt->refvalue) //判断输入是否为一个结束标记
		t = NULL;  //是 说明这棵二叉树是空树
	else
	{
		//创建树（子树）根结点
		t = (BinTreeNode*)malloc(sizeof(BinTreeNode));
		assert(t != NULL);
		t->data = *str;//为结点赋值
		CreateBinTree_4(bt,t->leftChild,++str);//创建左子树
		CreateBinTree_4(bt,t->rightChild,++str);//创建右子树
	}
}

        方式五
在这里插入图片描述

//根据二叉树的前序和中序序列创建树
void CreateBinTree_5(BinTree *bt, char *VLR, char *LVR, int n)
{
	//n结点个数
	CreateBinTree_5(bt->root,VLR,LVR,n);
}

void CreateBinTree_5(BinTreeNode *&t, char *VLR, char *LVR, int n)
{
	if(n == 0)
		t = NULL;
	else
	{
		int k = 0;
		//利用先序序列，查找根在中序序列的位置
		while(VLR[0] != LVR[k])
			k++;

		//创建根
		t = (BinTreeNode*)malloc(sizeof(BinTreeNode));
		assert(t != NULL);
		t->data = LVR[k];

		//创建t的左子树
		CreateBinTree_5(t->leftChild,VLR+1,LVR,k);
		//创建右子树
		CreateBinTree_5(t->rightChild,VLR+k+1,LVR+k+1,n-k-1);
	}
}

        方式六

在这里插入图片描述

//根据中序和后序序列创建二叉树
void CreateBinTree_6(BinTree *bt, char *LVR, char *LRV, int n)
{
	CreateBinTree_6(bt->root,LVR,LRV,n);
}
void CreateBinTree_6(BinTreeNode *&t, char *LVR, char *LRV, int n)
{
	if(n == 0)
		t = NULL;
	else
	{
		//利用后序序列，查找根在中序序列的位置
		int k = 0;
		while(LRV[n-1] != LVR[k]) //后序需要从后往前找根
			k++;

		//创建根结点
		t = (BinTreeNode*)malloc(sizeof(BinTreeNode));
		assert(t != NULL);
		t->data = LVR[k];
		//创建右子树
		CreateBinTree_6(t->rightChild,LVR+k+1,LRV+k,n-k-1);
		//创建左子树
		CreateBinTree_6(t->leftChild,LVR,LRV,k);
	}
}

二叉树遍历

1、递归方式

        先序遍历

//先序遍历
void PreOrder(BinTree *bt)
{
	PreOrder(bt->root);
}
void PreOrder(BinTreeNode *t)
{
	if(t != NULL)//树不为空
	{
		printf("%c ",t->data);//访问（子树）根结点
		PreOrder(t->leftChild);//访问左子树
		PreOrder(t->rightChild);//访问右子树
	}
}

        中序遍历

//中序遍历
void InOrder(BinTree *bt)
{
	InOrder(bt->root);
}
void InOrder(BinTreeNode *t)
{
	if(t != NULL)
	{
		InOrder(t->leftChild);//访问左子树
		printf("%c ",t->data);//访问（子树）根
		InOrder(t->rightChild);//访问右子树
	}
}

        后序遍历

//后序遍历
void PostOrder(BinTree *bt)
{
	PostOrder(bt->root);
}
void PostOrder(BinTreeNode *t)
{
	if(t != NULL)
	{
		PostOrder(t->leftChild);//访问左子树
		PostOrder(t->rightChild);//访问右子树
		printf("%c ",t->data);//访问（子树）根
	}
}

2、非递归方式

        层次遍历：层次遍历需要借用队列结构，此处给出队列的结构

//队列结构
struct BinTreeNode;

#define EType BinTreeNode*

typedef struct QueueNode
{
	EType data;
	struct QueueNode *next;
}QueueNode;

typedef struct LinkQueue
{
	QueueNode *front;
	QueueNode *tail;
}LinkQueue;

        下面介绍具体实现

//层次遍历
void LevelOrder(BinTree *bt)
{
	LevelOrder(bt->root);
}
void LevelOrder(BinTreeNode *t)
{
	if(t != NULL)
	{
		BinTreeNode *v;
		LinkQueue Q; //创建队列
		InitQueue(&Q); //对队列初始化
		EnQueue(&Q,t);//将二叉树根结点（地址）入队

		while(!QueueIsEmpty(&Q)) //判断队列是否为空
		{//不空
			GetHead(&Q,&v);//取（子树）根结点（地址）
			DeQueue(&Q);//将（子树）根结点（地址）出队
			printf("%c ",v->data);//打印出（子树）根结点的数据
			if(v->leftChild != NULL) //判断该结点的左树是否为空
				EnQueue(&Q,v->leftChild); //否 将左子树（地址）入队
			if(v->rightChild != NULL) //判断该结点右子树是否为空
				EnQueue(&Q,v->rightChild);//否 将右子树（地址）入队
		}
	}
}

        而对于先序遍历、中序遍历和后序遍历的非递归实现需要用到栈结构，下面给出它们的栈结构。

        先序遍历和中序遍历非递归形式使用的栈结构

struct BinTreeNode;
#define ET BinTreeNode*
typedef struct SeqStack
{
	ET *base;
	int       capacity;
	int       top;
}SeqStack;

        后序遍历非递归实现使用的栈结构

//栈结构
//左右标记
typedef enum{L,R}Tag;

typedef struct StkNode
{
	BinTreeNode *ptr; //保存结点地址
	Tag          tag; //标记（标记左还是右）
}StkNode;

#define ET StkNode
typedef struct SeqStack
{
	ET *base;
	int       capacity;
	int       top;
}SeqStack;

        下面介绍具体实现：

        先序遍历的非递归实现

//先序遍历的非递归实现
void PreOrder_1(BinTree *bt)
{
	PreOrder_1(bt->root);
}
void PreOrder_1(BinTreeNode *t)
{
	if(t != NULL) //判断二叉树是否为空
	{
		SeqStack st;   //申请一个栈
		InitStack(&st); //初始化栈
		BinTreeNode *p;
		Push(&st,t); //将二叉树的根结点入栈
		while(!IsEmpty(&st)) //判断栈顶是否为空
		{//否
			GetTop(&st,&p);//获取栈顶结点
			Pop(&st);//出栈
			printf("%c ",p->data);//打印数据
			/*这里需要注意的是栈结构是先进后出的，所以后访问的结点先入栈*/
			if(p->rightChild != NULL) //判断右子树是否为空
				Push(&st,p->rightChild); //否 入栈
			if(p->leftChild != NULL) //判断左子树是否为空
				Push(&st,p->leftChild); //否 入栈
		}
	}
}

        中序遍历的非递归实现

//中序遍历：非递归实现
void InOrder_1(BinTree *bt)
{
	InOrder_1(bt->root);
}
void InOrder_1(BinTreeNode *t)
{
	if(t != NULL) //判断二叉树是否为空
	{//不空
		SeqStack st; //设置一个栈结构
		InitStack(&st); //初始化栈
		BinTreeNode *p;
		Push(&st,t); //将根结点入栈
		while(!IsEmpty(&st)) //判断栈是否为空
		{//不空
			//判断左子树是否为空
			while(t!=NULL && t->leftChild!=NULL)
			{//不空
				Push(&st,t->leftChild);//左子树入栈
				t = t->leftChild;//位置下移
			}
			//此时已经走到了左子树的尽头
			//获取栈顶元素
			GetTop(&st,&p);
			Pop(&st); //出栈
			printf("%c ",p->data); //打印元素
			//判断右子树是否为空
			if(p->rightChild != NULL)
			{//不空
				t = p->rightChild;//访问右子树
				if(t != NULL) //将右子树入栈
					Push(&st,t);
			}
		}
	}
}

        后序遍历的递归实现

//后序遍历：非递归形式
void PostOrder(BinTree *bt)
{
	PostOrder(bt->root);
}
void PostOrder(BinTreeNode *t)
{
	if(t != NULL)
	{
		SeqStack st;
		InitStack(&st);
		BinTreeNode *p;
		StkNode sn;
		do
		{
			while(t != NULL)
			{
				sn.ptr = t;//指向二叉树树的根结点
				sn.tag = L; //刚开始访问左子树，标记为左
				Push(&st,sn);//入栈
				t = t->leftChild;//指向左子树的根结点
			}
			bool flag = true; //continue visit
			while(flag && !IsEmpty(&st))
			{
				GetTop(&st,&sn); //获取栈顶元素
				Pop(&st); //出栈
				p = sn.ptr; 
				switch(sn.tag) //看结点的标记信息
				{
				/*
					如果标记是左标记，说明接下来还需要访问右子树，不能访问根结点，
					如果标记是右标记，那么说明左右子树都已经访问完成可以访问根
				*/
				case L: //左标记：接下来还需要访问右子树
					sn.tag = R; //将左标记改为右
					Push(&st,sn); //重新入栈
					flag = false;
					t = p->rightChild;//接下来要访问右子树
					break;
				case R: //右标记 可以访问根结点，打印信息
					printf("%c ",p->data);
					break;
				}
			}
		}while(!IsEmpty(&st));//栈为空时，退出
	}
}

统计结点个数

//求以bt为根结点的二叉树结点个数
int Size(BinTree *bt)
{
	return Size(bt->root);
}
int Size(BinTreeNode *t)
{
	if(t == NULL)  //判断二叉树是否为空
		return 0;//是 记录个数为0
	else//否 该二叉树的结点个数=左子树结点个数+右子树结点个数+根结点个数（1）
		return Size(t->leftChild)+Size(t->rightChild)+1;
}

求二叉树高度

//求取二叉树的高度
int Height(BinTree *bt)
{
	return Height(bt->root);
}
int Height(BinTreeNode *t)
{
	if(t == NULL)  //判断二叉树是否为空
		return 0;//是 记录高度为0
	else
	{//否
		//求取左子树高度
		int left_height = Height(t->leftChild);
		//求取右子树高度
		int right_height = Height(t->rightChild);
		//返回：该二叉树高度=左子树与右子树的最大高度+1
		return (left_height>right_height ? left_height:right_height)+1;
	}
}

查找结点

//查找key值所在的结点
BinTreeNode* Search(BinTree *bt, ElemType key)
{
	return Search(bt->root,key);
}
BinTreeNode* Search(BinTreeNode *t, ElemType key)
{
	if(t == NULL) //判断二叉树是否为空
		return NULL; //是  说明不存在，返回空
	if(t->data == key) //否 判断结点值是否等于key值
		return t; //是  返回结点地址

	//没找到
	BinTreeNode *p = Search(t->leftChild,key); //查找左子树
	if(p != NULL)//判断是否找到
		return p;//找到  返回结点地址
	// 没找到
	return Search(t->rightChild,key); // 查找右子树，返回查找结果
}

查找某结点的父结点

//在bt二叉树中查找p结点的父结点
BinTreeNode* Parent(BinTree *bt, BinTreeNode *p)
{
	return Parent(bt->root,p);
}
BinTreeNode* Parent(BinTreeNode *t, BinTreeNode *p)
{
	if(t==NULL || p==NULL) //判断二叉树和结点是否为空
		return NULL;//是 返回空
	//否
	if(t->leftChild==p || t->rightChild==p)//判断t的左右孩子是否为p
		return t;// 是  返回其父结点
	//否
	BinTreeNode *q = Parent(t->leftChild,p);//查找t的左子树
	if(q != NULL)//判断左子树中是否找到满足条件的结点
		return q;// 是  返回
	//否
	return Parent(t->rightChild,p);//查找右子树
}

获取左子树

//获取二叉树的左子树
BinTreeNode* LeftChild(BinTreeNode *p)
{
	if(p != NULL)
		return p->leftChild;
	return NULL;
}

获取右子树

//获取二叉树的右子树  
BinTreeNode* RightChild(BinTreeNode *p)
{
	if(p != NULL)
		return p->rightChild;
	return NULL;
}

判断二叉树是否为空

//判断二叉树是否为空
bool BinTreeEmpty(BinTree *bt)
{
	return  bt->root==NULL;//判断根结点是否为空
}

拷贝二叉树

//拷贝二叉树:bt2拷贝到bt1
void Copy(BinTree *bt1, BinTree *bt2)
{
	Copy(bt1->root,bt2->root);
}
void Copy(BinTreeNode *&t1, BinTreeNode *t2)
{
	if(t2 == NULL) //判断t2是否为空
		t1 = NULL;//是 则无需拷贝，直接将t1置空
	else
	{//否

		//为t2（子树）根结点拷贝到t1（子树）根结点
		t1 = (BinTreeNode*)malloc(sizeof(BinTreeNode));
		assert(t1 != NULL);
		t1->data = t2->data;
		Copy(t1->leftChild,t2->leftChild);//拷贝t2左子树到t1左子树
		Copy(t1->rightChild,t2->rightChild);//拷贝t2右子树到t1右子树
	}
}

清空二叉树

//清空操作
void BinTreeClear(BinTree *bt)
{
	BinTreeClear(bt->root);
}
void BinTreeClear(BinTreeNode *&t)
{
	if(t != NULL) //判断二叉树是否为空
	{//否		
		BinTreeClear(t->leftChild);//清空左子树
		BinTreeClear(t->rightChild);//清空右子树
		free(t);//清空（子树）根
		t = NULL;
	}
}

结语

        对二叉树的介绍就到这里啦，希望这篇文章能给予你一些帮助，感谢各位人才的：点赞、收藏和评论，我们下次见。

附录

测试代码：二叉树详解（C语言版）

红心火柴
关注
  • 20
    点赞
  • 踩
  • 138
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
数据结构之平衡二叉树C语言版
Cukor丘克的博客
04-16 4724
作者：Cukor Zhong 什么是平衡二叉树 平衡二叉树是具有平衡属性的有序二叉树，所谓的平衡即当前树的左右子树高度差的绝对值不超过1。因为平衡二叉树是由苏联数学家Adelson-Velskii和Landis提出，所以又称为AVL树。 平衡二叉树的基本特点 是特殊的有序二叉树 左右子树高度差的绝对值不超过1 左右子树仍然是平衡二叉树
c语言二叉树
11-08
c语言实现的二叉树，包含二叉树的创建，前序遍历，中序遍历，后序遍历，亲测，可以输出
二叉树（C语言）
过客的博客
08-29 1937
文章目录二叉树二叉树的定义二叉树的几个重要性质二叉树的抽象数据类型定义二叉树的存储结构二叉树的遍历遍历二叉树的应用 二叉树 二叉树的定义 二叉树TTT：一个有穷的结点的集合。 这个结合可以为空 如不为空，则它由根结点和称为其 左子树TLT_LTL​ 和 右子树TRT_RTR​ 的两个不相交的二叉树组成。 二叉树具体五种基本形态。 空树 只有一个结点 只有一个结点和左子树 只有一个结点和...
【数据结构】C语言实现二叉树
最新发布
蒙奇D索大的博客
07-02 1444
【数据结构】第五章——树与二叉树 详细介绍如何通过C语言实现一棵二叉树……
C语言之二叉树
p=f/s
10-23 453
1、二叉树的基本概念 (1)、形如如下图所示的数据结构就叫做二叉树 (2)、二叉树的节点数据结构 struct TreeNode { int val; //节点的存储的数据 struct TreeNode *pLeft; //左子节点指针 struct TreeNode *pRight; //右子节点指针 }; (3)、...
C语言（二叉树）
莫等闲
04-14 561
二叉树也称为二分树，它是有限的节点集合，这个集合或者是空，或者是由一个根节点和两棵互不相交的称为左子树和右子树的二叉树构成。
C语言学习-二叉树
永不秃头的程序员的博客
04-05 724
一、二叉树的基本定义 1.1 基本概念 （1）完全二叉树 二叉树的最后一排（定义为n）只有一部分有子节点，剩余的（1 ~ n-1）二叉树的全部都有左右节点，我们把这样的二叉树叫为完全二叉树。 如图： （2）满二叉树（是二叉树的一种特列） 国际定义:除了叶结点外每一个结点都有左右子结点的二叉树。（每个节点都只有0个或者2个子节点）。 国内的定义是：除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树。从csdn来看，这种国内的被称作满二叉树的较多。 （3）扩充二叉树 扩充二叉树是对已有二叉树
线索二叉树详解（C语言版）.rar
04-10
在C语言中，线索二叉树的实现通常涉及到指针的高级操作和结构体的设计。下面我们将详细探讨线索二叉树的概念、结构以及C语言中的实现方法。 **线索二叉树概念** 线索二叉树是在普通二叉链表的基础上，为每个节点...
二叉树详解（C语言版）.rar
04-09
这篇博文的压缩包文件"二叉树详解（C语言版）.rar"包含了对二叉树的详细讲解和相关的C语言实现代码。 首先，我们需要了解二叉树的基本概念。二叉树是由节点构成的非线性数据结构，每个节点包含两个子节点，分别称为...
数据结构（C语言版） 第五章 树与二叉树 知识梳理 + 作业习题详解1
08-04
在C语言版的数据结构中，树的表示和操作是关键部分。本文主要梳理了树与二叉树的相关知识点，并包含了相关作业习题的详解。 首先，树被定义为一个有限集合，其中包含一个特殊的根节点以及可能的子树集合。每个子树...
C语言 数据结构平衡二叉树实例详解
01-20
语言：数据结构C语言版 编译环境：VC++ 6.0 日期： 2014-3-26 */ #include #include #include #define LH +1 // 左高 #define EH 0 // 等高 #define RH -1 // 右高 #define N 5 // 数据元素个数 typedef char...
二叉树C语言实现
02-28
二叉树的实现，创建，遍历（先序、中序、后序）添加，修改，删除
二叉树的建立（C语言）
12-31
数据结构二叉树建立的实现程序，任意输入三个字母以+双空格+一个字母+双空格+一个字母+双空格+回车。
二叉树（C语言版）
◆尐鑫孑◆ · 逆
02-22 969
     二叉树（Binary Tree）是另一种树型结构，它的特点是每个结点至多只有两棵子树（即二叉树中不存在度大于2的结点），并且，二叉树的字数由左右之分，顺序不可颠倒。     二叉树的存储结构：1.顺序存储结构 （仅适用于完全二叉树）  2.链式存储结构    二叉树的遍历：          先序遍历二叉树的操作定义为：  若二叉树为空，则空操作；否则          （1）访问根结点  （2）先序遍历左子树          （3）先序遍历右子树 中序遍历二叉树的操作定义为：  若二叉树为空，
【树】之二叉树(C语言)(含图解)
半生瓜のblog
06-16 2070
树&二叉树树树的概念及结构树的概念树的要求树的表示现实应用二叉树概念特殊的二叉树注意性质顺序存储链式存储构成&遍历结构定义前序遍历中序遍历后序遍历构建一个简单的树函数递归图——前序遍历结点个数叶子结点的个数层序遍历全部代码 树 树的概念及结构 树的概念 树是一种非线性的数据结构，它是由n(n >= 0)个有限结点组成的一个具有层次关系的集合，把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 有一个特殊的结点，称为根结点，根节点没有前驱结点。 除跟根结点外，其余
二叉树(c语言)
lixin203171613的博客
01-27 1027
树在数据结构中是属于非线性数据结构结构的一种。树是由结点或顶点和边组成的并且不存在着任何环的一种数据结构。没有结点的树称为空树。一棵非空的树包括一个根结点，还有多个附加结点，所有结点构成一个多级分层结构。一棵二叉树是结点的一个有限集合，该集合为空，或者是由一个根节点加上两棵称为左子树和右子树的二叉树组成。
C二叉树
gengxiaoying的专栏
06-25 1221
#include #include typedef char DataType;typedef struct Node { DataType data; /*数据域*/ struct Node *leftChild; /*左子树指针*/ struct Node *rightChild; /*右子树指针*/}BiTreeNode;
满二叉树与完全二叉树详解：C语言实践与数据结构应用
满二叉树是数据结构中的一个重要概念，特别是在C语言版的《数据结构》教材（严蔚敏、吴伟民编著，清华大学出版社）中被详细讨论。满二叉树有三个关键特点： 1. **节点分布规律**：满二叉树每一层的结点数总是等于该...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值