二叉树--兄弟孩子表示法

最新推荐文章于 2024-08-02 22:47:57 发布
最新推荐文章于 2024-08-02 22:47:57 发布
阅读量5.3k 收藏 1
点赞数 1 

//BTree.h

#ifndef _BTREE_H_
#define _BTREE_H_

#define BT_LEFT 0
#define BT_RIGHT 1

typedef void BTree;
typedef unsigned long long BTPos;

typedef struct _tag_BTreeNode BTreeNode;
struct _tag_BTreeNode
{
    BTreeNode* left;
    BTreeNode* right;
};

typedef void (BTree_Printf)(BTreeNode*);

BTree* BTree_Create();

void BTree_Destroy(BTree* tree);

void BTree_Clear(BTree* tree);

int BTree_Insert(BTree* tree, BTreeNode* node, BTPos pos, int count, int flag);

BTreeNode* BTree_Delete(BTree* tree, BTPos pos, int count);

BTreeNode* BTree_Get(BTree* tree, BTPos pos, int count);

BTreeNode* BTree_Root(BTree* tree);

int BTree_Height(BTree* tree);

int BTree_Count(BTree* tree);

int BTree_Degree(BTree* tree);

void BTree_Display(BTree* tree, BTree_Printf* pFunc, int gap, char div);

#endif


//BTree.c
#include <stdio.h>
#include <malloc.h>
#include "BTree.h"

typedef struct _tag_BTree TBTree;
struct _tag_BTree
{
    int count;
    BTreeNode* root;
};

static void recursive_display(BTreeNode* node, BTree_Printf* pFunc, int format, int gap, char div) // O(n)
{
    int i = 0;
    
    if( (node != NULL) && (pFunc != NULL) )
    {
        for(i=0; i<format; i++)
        {
            printf("%c", div);
        }
        
        pFunc(node);
        
        printf("\n");
        
        if( (node->left != NULL) || (node->right != NULL) )
        {
            recursive_display(node->left, pFunc, format + gap, gap, div);
            recursive_display(node->right, pFunc, format + gap, gap, div);
        }
    }
    else
    {
        for(i=0; i<format; i++)
        {
            printf("%c", div);
        }
        printf("\n");
    }
}

static int recursive_count(BTreeNode* root) // O(n)
{
    int ret = 0;
    
    if( root != NULL )
    {
        ret = recursive_count(root->left) + 1 + recursive_count(root->right);
    }
    
    return ret;
}

static int recursive_height(BTreeNode* root) // O(n)
{
    int ret = 0;
    
    if( root != NULL )
    {
        int lh = recursive_height(root->left);
        int rh = recursive_height(root->right);
        
        ret = ((lh > rh) ? lh : rh) + 1;
    }
    
    return ret;
}

static int recursive_degree(BTreeNode* root) // O(n)
{
    int ret = 0;
    
    if( root != NULL )
    {
        if( root->left != NULL )
        {
            ret++;
        }
        
        if( root->right != NULL )
        {
            ret++;
        }
        
        if( ret == 1 )
        {
            int ld = recursive_degree(root->left);
            int rd = recursive_degree(root->right);
            
            if( ret < ld )
            {
                ret = ld;
            }
            
            if( ret < rd )
            {
                ret = rd;
            }
        }
    }
    
    return ret;
}

BTree* BTree_Create() // O(1)
{
    TBTree* ret = (TBTree*)malloc(sizeof(TBTree));
    
    if( ret != NULL )
    {
        ret->count = 0;
        ret->root = NULL;
    }
    
    return ret;
}

void BTree_Destroy(BTree* tree) // O(1)
{
    free(tree);
}

void BTree_Clear(BTree* tree) // O(1)
{
    TBTree* btree = (TBTree*)tree;
    
    if( btree != NULL )
    {
        btree->count = 0;
        btree->root = NULL;
    }
}

int BTree_Insert(BTree* tree, BTreeNode* node, BTPos pos, int count, int flag) // O(n) 
{
    TBTree* btree = (TBTree*)tree;
    int ret = (btree != NULL) && (node != NULL) && ((flag == BT_LEFT) || (flag == BT_RIGHT));
    int bit = 0;
    
    if( ret )
    {
        BTreeNode* parent = NULL;
        BTreeNode* current = btree->root;
        
        node->left = NULL;
        node->right = NULL;
        
        while( (count > 0) && (current != NULL) )
        {
            bit = pos & 1;
            pos = pos >> 1;
            
            parent = current;
            
            if( bit == BT_LEFT )
            {
                current = current->left;
            }
            else if( bit == BT_RIGHT )
            {
                current = current->right;
            }
            
            count--;
        }
        
        if( flag == BT_LEFT )
        {
            node->left = current;
        }
        else if( flag == BT_RIGHT )
        {
            node->right = current;
        }
        
        if( parent != NULL )
        {
            if( bit == BT_LEFT )
            {
                parent->left = node;
            }
            else if( bit == BT_RIGHT )
            {
                parent->right = node;
            }
        }
        else
        {
            btree->root = node;
        }
        
        btree->count++;
    }
    
    return ret;
}

BTreeNode* BTree_Delete(BTree* tree, BTPos pos, int count) // O(n)
{
    TBTree* btree = (TBTree*)tree;
    BTreeNode* ret = NULL; 
    int bit = 0;
    
    if( btree != NULL )
    {
        BTreeNode* parent = NULL;
        BTreeNode* current = btree->root;
        
        while( (count > 0) && (current != NULL) )
        {
            bit = pos & 1;
            pos = pos >> 1;
            
            parent = current;
            
            if( bit == BT_LEFT )
            {
                current = current->left;
            }
            else if( bit == BT_RIGHT )
            {
                current = current->right;
            }
            
            count--;
        }
        
        if( parent != NULL )
        {
            if( bit == BT_LEFT )
            {
                parent->left = NULL;
            }
            else if( bit == BT_RIGHT )
            {
                parent->right = NULL;
            }
        }
        else
        {
            btree->root = NULL;
        }
        
        ret = current;
        
        btree->count = btree->count - recursive_count(ret);
    }
    
    return ret;
}

BTreeNode* BTree_Get(BTree* tree, BTPos pos, int count) // O(n)
{
    TBTree* btree = (TBTree*)tree;
    BTreeNode* ret = NULL; 
    int bit = 0;
    
    if( btree != NULL )
    {
        BTreeNode* current = btree->root;
        
        while( (count > 0) && (current != NULL) )
        {
            bit = pos & 1;
            pos = pos >> 1;
            
            if( bit == BT_LEFT )
            {
                current = current->left;
            }
            else if( bit == BT_RIGHT )
            {
                current = current->right;
            }
            
            count--;
        }
        
        ret = current;
    }
    
    return ret;
}

BTreeNode* BTree_Root(BTree* tree) // O(1)
{
    TBTree* btree = (TBTree*)tree;
    BTreeNode* ret = NULL;
    
    if( btree != NULL )
    {
        ret = btree->root;
    }
    
    return ret;
}

int BTree_Height(BTree* tree) // O(n)
{
    TBTree* btree = (TBTree*)tree;
    int ret = 0;
    
    if( btree != NULL )
    {
        ret = recursive_height(btree->root);
    }
    
    return ret;
}

int BTree_Count(BTree* tree) // O(1)
{
    TBTree* btree = (TBTree*)tree;
    int ret = 0;
    
    if( btree != NULL )
    {
        ret = btree->count;
    }
    
    return ret;
}

int BTree_Degree(BTree* tree) // O(n)
{
    TBTree* btree = (TBTree*)tree;
    int ret = 0;
    
    if( btree != NULL )
    {
        ret = recursive_degree(btree->root);
    }
    
    return ret;
}

void BTree_Display(BTree* tree, BTree_Printf* pFunc, int gap, char div) // O(n)
{
    TBTree* btree = (TBTree*)tree;
    
    if( btree != NULL )
    {
        recursive_display(btree->root, pFunc, 0, gap, div);
    }
}


//main.c

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

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

struct Node
{
    BTreeNode header;
    char v;
};

void printf_data(BTreeNode* node)
{
    if( node != NULL )
    {
        printf("%c", ((struct Node*)node)->v);
    }
}

int main(int argc, char *argv[])
{
    BTree* tree = BTree_Create();
    
    struct Node n1 = {{NULL, NULL}, 'A'};
    struct Node n2 = {{NULL, NULL}, 'B'};
    struct Node n3 = {{NULL, NULL}, 'C'};
    struct Node n4 = {{NULL, NULL}, 'D'};
    struct Node n5 = {{NULL, NULL}, 'E'};
    struct Node n6 = {{NULL, NULL}, 'F'};
    
    BTree_Insert(tree, (BTreeNode*)&n1, 0, 0, 0);
    BTree_Insert(tree, (BTreeNode*)&n2, 0x00, 1, 0);
    BTree_Insert(tree, (BTreeNode*)&n3, 0x01, 1, 0);
    BTree_Insert(tree, (BTreeNode*)&n4, 0x00, 2, 0);
    BTree_Insert(tree, (BTreeNode*)&n5, 0x02, 2, 0);
    BTree_Insert(tree, (BTreeNode*)&n6, 0x02, 3, 0);
    
    printf("Height: %d\n", BTree_Height(tree));
    printf("Degree: %d\n", BTree_Degree(tree));
    printf("Count: %d\n", BTree_Count(tree));
    printf("Position At (0x02, 2): %c\n", ((struct Node*)BTree_Get(tree, 0x02, 2))->v);
    printf("Full Tree: \n");
    
    BTree_Display(tree, printf_data, 4, '-');
    
    BTree_Delete(tree, 0x00, 1);
    
    printf("After Delete B: \n");
    printf("Height: %d\n", BTree_Height(tree));
    printf("Degree: %d\n", BTree_Degree(tree));
    printf("Count: %d\n", BTree_Count(tree));
    printf("Full Tree: \n");
    
    BTree_Display(tree, printf_data, 4, '-');
    
    BTree_Clear(tree);
    
    printf("After Clear: \n");
    printf("Height: %d\n", BTree_Height(tree));
    printf("Degree: %d\n", BTree_Degree(tree));
    printf("Count: %d\n", BTree_Count(tree));
    
    BTree_Display(tree, printf_data, 4, '-');
    
    BTree_Destroy(tree);
    
	return 0;
}


//my design --BTree.c

#include "BTree.h"
#include <malloc.h>
#include <stdio.h>


typedef struct _tag_TBTree TBTree;
struct _tag_TBTree     //define the node of header 
{
	int count;
	BTreeNode* root;
};

static int recursive_degree(BTreeNode* root)
{
	int ret = 0;
	if(root!=NULL)
	{
		if(root->left!=NULL)
		{
			ret++;	
		}	
		if(root->right!=NULL)
		{
			ret++;	
		}
		if(ret == 1)
		{
			int ld = recursive_degree(root->left);
			int rd = recursive_degree(root->right);	
			
			if(ret < ld)
			{
				ret = ld;	
			}
			if(ret < rd)
			{
				ret = rd;	
			}
		}
	}
	return ret;
}
static int recursive_height(BTreeNode* root)
{
	int ret = 0;
	if(root!=NULL)
	{
		int lh = recursive_height(root->left);
		int rh = recursive_height(root->right);	
		ret = ((lh>rh)?lh:rh) + 1;
	}
	return ret;
}
static int recursive_count(BTreeNode* node)
{
	int ret = 0;
	
	if(node!=NULL)
	{
		ret = recursive_count(node->left) + 1 + recursive_count(node->right);	
	}
	return ret;
}
static void recursive_display(BTreeNode* node,BTree_Printf* pFunc,int format,int gap,char div)
{
	int i = 0;
	if((node!=NULL)&&(pFunc!=NULL))
	{
		for(i=0;i<format;i++)
		{
			printf("%c",div);	
		}
		pFunc(node);
		printf("\n");
		if((node->left!=NULL)||(node->right!=NULL))
		{
			recursive_display(node->left,pFunc,format+gap,gap,div);
			recursive_display(node->right,pFunc,format+gap,gap,div);	
		}	
	}
	else   //when there  has only-left child node or only-right child node,print the char to fill the place
	{
		for(i=0;i<format;i++)
		{
			printf("%c",div);	
		}
		printf("\n");	
	}	
}

BTree* BTree_Create()
{
	TBTree* ret = (TBTree*)malloc(sizeof(TBTree));
	if(ret != NULL)
	{
		ret->count = 0;
		ret->root = NULL;	
	}
	return ret;
}
void BTree_Destroy(BTree* tree)
{
	free(tree);
}

void BTree_Clear(BTree* tree)
{
	TBTree* btree = (TBTree*)tree;
	if(btree != NULL)
	{
		btree->count = 0;
		btree->root = NULL;	
	}
}

int BTree_Insert(BTree* tree,BTreeNode* node,BTPos pos,int count,int flag)   // pos :position; count :moving times;
{
	int ret = 0;
	int bit = 0;
	TBTree* btree = (TBTree*)tree;
	ret = (btree!=NULL)&&(node!=NULL)&&((flag==BT_LEFT)||(flag==BT_RIGHT));
	if(ret)
	{
		BTreeNode* parent = NULL;
		BTreeNode* current = btree->root;		
		
		node->left = NULL;
		node->right = NULL;
		
		while((count>0)&&(current!=NULL))
		{
			bit = pos & 1;
			pos = pos >> 1;
			
			parent = current;
			
			if(bit==BT_LEFT)
			{
				current = current->left;	
			}
			else if(bit==BT_RIGHT)
			{
				current = current->right;	
			}
			count--;
			
		}
		if(flag==BT_LEFT)    //when the current node has some children node,the current node should be inserted after the node
		{
			node->left = current;	
		}
		else if(flag == BT_RIGHT)
		{
			node->right = current;	
		}	
		
		if(parent!=NULL)
		{
			if(bit == BT_LEFT)
			{
				parent->left = node;		
			}	
			else if(bit == BT_RIGHT)
			{
				parent->right = node;
			}
		}
		else      //insert the first node
		{
			btree->root = node;	
		}
		btree->count++;
	}

	return ret;
} 

void BTree_Display(BTree* tree,BTree_Printf* pFunc,int gap,char div)
{
	TBTree* btree = (TBTree*)tree;
	if((btree!=NULL)&&(pFunc!=NULL))
	{
		recursive_display(btree->root,pFunc,0,gap,div);
	}
}

BTreeNode* BTree_Delete(BTree* tree,BTPos pos,int count)
{
	BTreeNode* ret = NULL;
	TBTree* btree = (TBTree*)tree;      //×öÒ»¸ö¿Ç 
	int bit = 0;
	if(btree!=NULL)
	{
		BTreeNode* parent = NULL;
		BTreeNode* current = btree->root;
		while((count>0)&&(current!=NULL))
		{
			bit = pos & 1;
			pos = pos >> 1;
			
			parent = current;
			
			if(bit==BT_LEFT)
			{
				current = current->left;	
			}	
			else if(bit==BT_RIGHT)
			{
				current = current->right;
			}
			count--;
		}
		if(parent!=NULL)
		{
			if(bit==BT_LEFT)
			{
				parent->left = NULL;	
			}	
			else if(bit == BT_RIGHT)
			{
				parent->right = NULL;	
			}
		}
		else   //the only one node
		{
			btree->root = NULL;	
		}
		ret = current;    //important
		
		btree->count = btree->count - recursive_count(ret);
	}
	return ret;
}
BTreeNode* BTree_Get(BTree* tree,BTPos pos,int count)
{
	BTreeNode* ret = NULL;
	TBTree* btree = (TBTree*)tree;
	int bit = 0;
	if(btree!=NULL)
	{
		BTreeNode* parent = NULL;
		BTreeNode* current = btree->root;
		
		while((count>0)&&(current!=NULL))
		{
			bit = pos & 1;
			pos = pos >> 1;	
			
			parent = current;      //record the current node
			
			if(bit == BT_LEFT)
			{
				current = current->left;	
			}
			else if(bit == BT_RIGHT)
			{
				current = current->right;	
			}
			count--;
		}	
		ret = current;   //important
	}
	return ret;
}

BTreeNode* BTree_Root(BTree* tree)
{
	BTreeNode* ret = NULL;
	TBTree* btree = (TBTree*)tree;
	if(btree != NULL)
	{
		ret = btree->root;	
	}
	return ret;
}

int BTree_Height(BTree* tree)
{
	int ret = 0;
	TBTree* btree = (TBTree*)tree;
	if(btree!=NULL)
	{
		ret = recursive_height(btree->root);		
	}
	return ret;
}
int BTree_Count(BTree* tree)
{
	int ret = 0;
	TBTree* btree = (TBTree*)tree;
	if(btree!=NULL)
	{
		ret = btree->count;	
	}
	return ret;
}

int BTree_Degree(BTree* tree)
{
	int ret = 0;
	TBTree* btree = (TBTree*)tree;
	if(btree!=NULL)
	{
		ret = recursive_degree(btree->root);	
	}
	return ret;
}




daa20
关注
专栏目录
将森林转变成二叉树（用孩子兄弟表示法）
数据结构和算法教程（C语言版）
01-01 699
森林转化为二叉树，更多的是为了对森林中的节点做遍历操作。转化前的森林与转化后的二叉树相比，其层次遍历和后序遍历的访问节点顺序不同，而先序遍历和中序遍历访问节点的顺序是相同的。如图 2 所示，先将森林包含的所有普通树各自转化为二叉树，然后将其他树的根节点看作为第一棵二叉树的兄弟节点，采用孩子兄弟表示法连接到一起。提示：由二叉树转化为森林的过程也就是森林转化二叉树的逆过程，也就是图 2 中由 c) 到 b) 再到 a) 的过程。同样地，遍历图 2c) 中的二叉树，得到的先序序列为。，中序遍历得到的序列为。
5. 树的存储结构：【双亲表示法、孩子表示法、孩子兄弟表示法】+【树、森林和二叉树的转换】
你说的白是什么白_
08-13 1482
树的存储结构：【双亲表示法、孩子表示法、孩子兄弟表示法】+【树、森林和二叉树的转换】
孩子兄弟链表法表示二叉树C++
10-30
孩子兄弟链表法表示二叉树C++ 孩子兄弟链表法表示二叉树C++
二叉树之孩子表示法以及前中后三种遍历法
qq_30747875的博客
10-06 695
文章目录题目思路AC代码 题目 思路 对于每一个结点，我们可以构造一个结构体变量struct node，其中包含数据、左孩子结点、右孩子结点。然后依次存入即可，遍历的话，使用简单的递归遍历即可。 AC代码 #include <bits/stdc++.h> using namespace std; /* 1.先用孩子表示法，存储二叉树 2.用递归得结果 */ const int N = 30; struct node { char data; int lchild, rchild; }
【数据结构】二叉树基本操作（孩子兄弟表示法 + Java详解 + 原码）
最新发布
明志の博客
08-02 839
学习二叉树一定要结合图形，要掌握递归的思想，就是将一个大问题划分成相同的小问题二叉树部分要掌握前序、中序、后序、层序四种遍历方式，因为好多题就是基于这四种遍历方式的变种例如：求最大宽度求这棵树的左视图求这棵树的右视图。
二叉树的孩子兄弟表示法
AnnotationBeanUtils
03-04 2293
初学者。如果有误请指正，欢迎联系QQ2684162190初学者。 #include<stdio.h> #include<stdlib.h> #define MAX_TREE_SIZE 100 typedef struct Node { char date; struct Node *lchild,*rchild; }BiTNode,*BiTree; /*根据二叉树的括号表示...
双亲表示法、孩子表示法、孩子兄弟表示法(二叉树表示法)，森林和二叉树的转换
ker的博客
01-22 4万+
树的存储结构一、双亲表示法 一、双亲表示法 实现：定义数组结构存放树的结点，每个结点含两个域： 数据域：存放结点本身数据信息。 双亲域：指示本结点的双亲结点在数组中的位置。 结点结构表示为： data parent data是数据域，parent是指针域 例如： 可表示为： r=0,n=10.(根结点位置和结点个数) 这样的存储结构，根据结点parent指针很容易找到它的双...
数据结构 模拟实现二叉树（孩子表示法）
cool_tao6的博客
01-13 2219
/孩子表示法char val;
6-树与二叉树-2-预习.pdf
10-23
孩子兄弟表示法是指每个结点都有两个指针，一个指向其第一个孩子结点，另一个指向其兄弟结点，这种方法可以快速地找到某个结点的所有孩子结点和兄弟结点。 树的遍历是指从树的根结点开始，按照某种顺序访问树中的每...
数据结构-树和二叉树-PPT
02-04
树的表示方法有多种，如树形表示法、文氏图表示法、凹入图表示法、广义表表示法等。 树的基本术语包括： * 结点的度与树的度：树中某个结点的子树的个数称为该结点的度。树中各结点的度的最大值称为树的度，通常将...
算法-理论基础- 二叉树- 树、森林、二叉树的转换（包含源程序）.rar
09-16
1. 树到二叉树的转换：为了将一棵树转换为二叉树，我们可以采用孩子兄弟表示法。每个节点的左子节点成为原树中该节点的第一个孩子，右子节点成为原树中当前节点的下一个兄弟。如果某个节点没有孩子，那么它的左子...
孩子兄弟表示法(二叉链表树)
热门推荐
RowandJJ
06-02 5万+
考虑下面这森林： 如果用孩子兄弟表示法可以表示为： 顾名思义，孩子兄弟表示法的每个节点有两个指针域，一个指向其长子，另一个指向其兄弟. 实现： /************************************************** 树的孩子兄弟表示法(二叉链表树) by Rowandjj 2014/5/25 ***********
孩子兄弟表示法(二叉链表树) 时间 2014-06-02 16:32:17 CSDN博客 原文 http://blog.csdn.net/chdjj/article/details/2811164
muscledex的博客
06-27 814
孩子兄弟表示法(二叉链表树) 时间 2014-06-02 16:32:17  CSDN博客 原文  http://blog.csdn.net/chdjj/article/details/28111643 主题 二叉树 考虑下面这森林：   如果用孩子兄弟表示法可以表示为：    顾名思义，孩子兄弟表示法的每个节点有两个指针域，一个指向
判断二叉树中的两个结点是否为兄弟结点或者堂兄弟结点
qq_43661234的博客
11-19 3501
兄弟: 深度相同, 双亲节点相同(同一个结点不能是兄弟)。 堂兄弟: 深度相同，双亲节点不同。 若询问的两个结点是兄弟，输出"brother" , 若询问的两个结点是堂兄弟，输出"cousin" ,否则输出"other relationship" 同一个结点的关系是“other relationship" #include<stdio.h> #include<stdlib.h&g...
【数据结构·考研】树的孩子兄弟表示法
Jiawen9的博客
09-03 1万+
树的孩子兄弟表示法 也叫树的二叉树表示法。 树的左指针指向自己的第一个孩子，右指针指向与自己相邻的兄弟。 结构的最大优点是：它和二叉树的二叉链表表示完全一样。可利用二叉树的算法来实现对树的操作 。 左孩子右兄弟表示的树的高度 因为二叉树表示法的根节点没有右孩子，所以树高就是左子树树高 + 1。 然后我们看下根节点第一个孩子的高度，由于第一个孩子的右子树和第一个孩子的高度是相同的，所以比较左子树 + 1的高度来和右子树来比较，如果 左子树 + 1 > 右子树，高度取左子树 + 1，否则取右.
二叉链表（孩子—兄弟）存储表示（代码实现）
weixin_62659979的博客
11-08 684
二叉链表（孩子—兄弟）存储表示（代码实现）
二叉树（左右孩子法实现）
samuel24276的博客
03-11 2136
头文件BiTree.h#include&lt;iostream&gt;const int MAXSIZE=20;template&lt;class T&gt;struct BiTNode{    T data;    struct BiTNode&lt;T&gt; *lch;    struct BiTNode&lt;T&gt; *rch;};template&lt;class T&gt;clas...
普通树（双亲表示法存储）转二叉树【左孩子右兄弟表示法】
qq_33768452的博客
08-20 3645
普通树（双亲表示法存储）转二叉树【左孩子右兄弟表示法】
树与二叉树表示：子女-兄弟表示法
“子女-兄弟表示-树与二叉树”是一种数据结构的表示方法，用于将树转换成...通过子女-兄弟表示法，我们可以将这些概念转化为二叉树结构，方便在程序中进行操作和算法实现，例如树的遍历、查找、插入和删除等操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值