第六周day3

最新推荐文章于 2024-10-05 15:32:05 发布
最新推荐文章于 2024-10-05 15:32:05 发布
阅读量54 收藏
点赞数
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56569448/article/details/129997761
版权

树型结构：

    1、树的基本概念

        一种表示层次关系(一对多)的数据结构

        有且仅有一个特定的节点，该节点没有前趋，被称为根节点

        剩余的n个不相交的子集，其中每个子集也都是一颗树，被称为它们根节点的子树

        注意：树型结构有递归性(树中有树)

    2、数的表示方式：

        倒悬树、嵌套法、凹凸法

    3、树的专业术语

        节点：组成树的基本元素，同时它也是一棵树

        节点的度：该节点的子树数量

        树的度：树中节点的数量

        树的层次：从根节点层次为1出发计算

        树的深度：树的最大层次树

        叶子节点：节点的度为0的节点

        双亲节点和孩子节点：节点的子树称为该节点的孩子节点，该节点就是它们孩子节点的双亲节点

        兄弟节点：具有同一个双亲的节点，互为兄弟节点

        堂兄弟节点：双亲节点在同一层次的节点，互为堂兄弟节点

        祖先节点：从根节点出发到该节点，经过的所有节点都称为该节点的祖先节点

        子孙节点：一个节点的子树中任意一个节点都是它的子孙节点

        森林：n个不相交的树组成的集合称为森林

    4、树的存储

        树可以顺序存储，也可以链式存储，还可以混合存储，由于存储的信息的不同，有以下的存储表示方式：

#ifndef LIST_QUEUE_H
#define LIST_QUEUE_H
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#define TYPE int
//设计单链表的节点
typedef struct Node
{
	TYPE data;//节点的数据域
	struct Node* next;//节点的指针域
}Node;

//创建节点
Node* creat_node(TYPE data);


//链式队列
typedef struct ListQueue
{
	Node* head;
	Node* tail;
	size_t cnt;
}ListQueue;

//创建
ListQueue* creat_list_queue(void);


//队空
bool empty_list_queue(ListQueue* queue);


//入队
void push_list_queue(ListQueue* queue,TYPE val);


//出队
bool pop_list_queue(ListQueue* queue);


//队头
TYPE head_list_queue(ListQueue* queue);


//队尾
TYPE tail_list_queue(ListQueue* queue);


//数量
size_t size_list_queue(ListQueue* queue);


//销毁
void destroy_list_queue(ListQueue* queue);



#endif//LIST_QUEUE_H

       

#include "list_queue.h"

#define TYPE int


//创建节点
Node* creat_node(TYPE data)
{
	//分配存储节点的内存
	Node* node=malloc(sizeof(Node));
	node->data=data;
	node->next=NULL;
	return node;
}


//创建
ListQueue* creat_list_queue(void)
{
	ListQueue* queue=malloc(sizeof(ListQueue));
	queue->head = NULL;
	queue->tail = NULL;
	queue->cnt=0;
	return queue;
}

//队空
bool empty_list_queue(ListQueue* queue)
{
	return 0 == queue->cnt;
}

//入队
void push_list_queue(ListQueue* queue,TYPE val)
{
	Node* node=creat_node(val);
	if(empty_list_queue(queue))
	{
		queue->head = node;
		queue->tail = node;
	}
	else
	{
		queue->tail->next = node;
		queue->tail = node;
	}
	queue->cnt++;
}

//出队
bool pop_list_queue(ListQueue* queue)
{
	if(empty_list_queue(queue)) return false;
	Node* temp = queue->head;
	queue->head = temp->next;
	free(temp);
	queue->cnt--;
	if(empty_list_queue(queue)) queue->tail=NULL;
	return true;
}

//队头
TYPE head_list_queue(ListQueue* queue)
{
	return queue->head->data;
}

//队尾
TYPE tail_list_queue(ListQueue* queue)
{
	return queue->tail->data;
}

//数量
size_t size_list_queue(ListQueue* queue)
{
	return queue->cnt;
}

//销毁
void destroy_list_queue(ListQueue* queue)
{
	while(pop_list_queue(queue));
	free(queue);
}

双亲表示法：

            顺序存储：

                位置    data    双亲位置

                0       A       -1

                1       B       0

                2       C       0

                3       D       0

                4       E       1

                5       F       1

                6       G       3

                7       H       3

                8       I       7

                优点：方便找到双亲

                缺点：查找孩子节点不方便

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "list_queue.h"
//双亲表示法

typedef struct TreeNode
{
	char data;	//数据
	int parent;	//双亲下标
}TreeNode;

typedef struct Tree
{
	TreeNode* arr;	//存储节点内存首地址
	int cal;		//容量
	int cnt;		//节点数量
}Tree;

//创建数结构
Tree* creat_tree(int cal)
{
	Tree* tree=malloc(sizeof(Tree));
	tree->arr=malloc(sizeof(TreeNode)*cal);
	tree->cal=cal;
	tree->cnt=0;
	return tree;
}

bool add_tree(Tree* tree,char data,char pdata)
{
	//树不能存在满的情况，考虑扩容
	if(tree->cnt >= tree->cal)
	{
		tree->cal*=2;
		tree->arr=realloc(tree->arr,sizeof(TreeNode)*tree->cal);
	}

	//加入的是跟节点
	if('\0' == pdata)
	{
		tree->arr[0].data=data;
		tree->arr[0].parent=-1;
		tree->cnt++;
		return true;
	}
	for(int i=0;i<tree->cnt;i++)
	{
		if(pdata == tree->arr[i].data)
		{
			tree->arr[tree->cnt].data=data;
			tree->arr[tree->cnt++].parent=i;
			return true;
		}
	}
	return false;
}

void show_tree(Tree* tree)
{
	for(int i=0;i<tree->cnt;i++)
	{
		printf("index:%d data:%c parent:%d\n",i,tree->arr[i].data,tree->arr[i].parent);
	}
}

//计算节点的度
int node_sub_count(Tree* tree,char data)
{
	int index=-1;
	int count=0;
	for(int i=0;i<tree->cnt;i++)
	{
		if(data == tree->arr[i].data)
		{
			index=i;
			break;
		}
	}
	if(-1 == index)	return -1;
	for(int i=0;i<tree->cnt;i++)
	{
		if(index == tree->arr[i].parent) count++;
	}
	return count;
}

int _tree_high(Tree* tree,char data)
{
	//计算节点data的高度
	int index=-1;
	for(int i=0;i<tree->cnt;i++)
	{
		if(data == tree->arr[i].data)
		{
			index=i;
			break;
		}
	}
	int max_sub_high=0;
	for(int i=0;i<tree->cnt;i++)
	{
		if(index == tree->arr[i].parent)
		{
			int high =_tree_high(tree,tree->arr[i].data);
			if(high>max_sub_high) max_sub_high=high;
		}
	}
	return max_sub_high+1;
}

int tree_high(Tree* tree)
{
	return _tree_high(tree,tree->arr[0].data);
}

//层序遍历普通树
void layer_show_tree(Tree* tree)
{
	//创建队列
	ListQueue* queue =creat_list_queue();

	//跟节点入队
	push_list_queue(queue,tree->arr[0].data);
	while(!empty_list_queue(queue))
	{
		//获取队头并出队
		char data=head_list_queue(queue);
		pop_list_queue(queue);
		printf("%c ",data);

		//找data的孩子并入队
		int index=-1;
		for(int i=0;i<tree->cnt;i++)
		{
			if(data == tree->arr[i].data)
			{
				index=i;
				break;
			}
		}
		for(int i=0;i<tree->cnt;i++)
		{
			if(index == tree->arr[i].parent)
			{
				push_list_queue(queue,tree->arr[i].data);
			}
		}
	}
	//销毁队列
	printf("\n");
	destroy_list_queue(queue);
}

int main(int argc,const char* argv[])
{
	Tree* tree=creat_tree(10);
	add_tree(tree,'A','\0');
	add_tree(tree,'B','A');
	add_tree(tree,'C','A');
	add_tree(tree,'D','A');
	add_tree(tree,'E','B');
	add_tree(tree,'F','B');
	add_tree(tree,'G','D');
	add_tree(tree,'H','D');
	add_tree(tree,'I','H');
	show_tree(tree);
	printf("sub_cnt:%d\n",node_sub_count(tree,'A'));
	printf("high:%d\n",tree_high(tree));
	layer_show_tree(tree);
}

        孩子表示法：

            顺序存储：

                位置    data    存储孩子位置的数组sub_arr[n-1]

                0       A       1、2、3

                1       B       4、5

                2       C  

                3       D       6、7

                4       E      

                5       F      

                6       G      

                7       H       8

                8       I      

            链式存储： 节省空间

                位置    data    ListHead

                0       A       1->2->3->N

                1       B       4->5->N

                2       C      

                3       D       6->7->N

                4       E      

                5       F      

                6       G      

                7       H       8->N

                8       I      

            优点：方便找到孩子

            缺点：查找双亲节点不方便

        兄弟表示法：

            双亲只存储第一个子节点，链式指向所有的兄弟节点

            优点：方便找到所有的的兄弟节点、孩子节点

            缺点：不方便找双亲

    注意：普通树不常用，一般会把普通树转换成二叉树使用

二叉树：

    是一种常用的数据结构，处理起来比较简单方便，并且普通树可以很方便地转换成二叉树

    普通树转二叉树：孩子变左节点，兄弟变右节点

    定义：节点的度最多为2

   

    二叉树是n个有限元素的集合，该集合或者为空、或者由一个成为根的元素及两个不相交的、被分别成为左子树和右子树的二叉树组成，是有序树。当集合为空时，称该二叉树为空二叉树。在二叉树，一个元素也成为一个节点

特殊的二叉树：

    满二叉树：如果一棵二叉树只有度为0的节点和度为2的节点，并且度为0的节点在同一层上，则这棵二叉树为满二叉树。(每层节点都满足2^(i-1)个)

   

    完全二叉树：深度为k，有n个节点的二叉树当且仅当其每一个节点都与深度为k的满二叉树中编号从1到n的节点一一对应时，称为完全二叉树。

二叉树的性质：【重点】

    性质1：二叉树的第i层上至多有2^(i-1)(i≥1)个节点。

   

    性质2：深度为h的二叉树中至多含有2^h-1个节点。

   

    性质3：若在任意一棵二叉树中，有n0个叶子节点，有n2个度为2的节点，则必有n0=n2+1。

   

    性质4：具有n个节点的满二叉树深为log2n+1。

   

    性质5：若对一棵有n个节点的完全二叉树进行顺序编号（1≤i≤n），那么，对于编号为i（i≥1）的节点

    当i=1时，该节点为根，它无双亲节点。

    当i>1时，该节点的双亲节点的编号为i/2。

    若2i≤n，则有编号为2i的左节点，否则没有左节点。

    若2i+1≤n，则有编号为2i+1的右节点，否则没有右节点。

二叉树的常用操作：

    构建、销毁、遍历、高度、密度、添加、删除、查询、求左、求右、求根

二叉树的遍历：

    前序遍历：根、左、右

    中序遍历：左、根、右

    后序遍历：左、右、根

        注意：前中后由根节点的遍历次序决定，并且左右子树的次序不会改变

        注意：根据中序+前序或者中序+后序 可以还原一棵树

        无法通过前序+后序还原

    层序遍历：从上到下，从左到右依次遍历，必须与队列配合

二叉树的存储：

    顺序存储：必须按照完全二叉树的格式存储，空位置使用特殊数据代替

    数据项：

        存储节点的内存首地址

        容量

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include "list_queue.h"

#define TREE_TYPE char

typedef struct BinTree
{
	TREE_TYPE* arr;
	size_t cal;
}BinTree;

//构建 '#'空位置
BinTree* creat_tree(const TREE_TYPE* arr,size_t len)
{
	BinTree* tree=malloc(sizeof(BinTree));
	tree->arr=malloc(sizeof(TREE_TYPE)*len);
	memcpy(tree->arr,arr,sizeof(TREE_TYPE)*len);
	tree->cal=len;
	return tree;
}

//对编号为index的节点进行前序遍历
void _dlr_show(BinTree* tree,size_t index)
{
	if(index-1>=tree->cal || '#' == tree->arr[index-1]) return;
	//根
	printf("%c ",tree->arr[index-1]);	
	//左
	_dlr_show(tree,index*2);
	//右
	_dlr_show(tree,index*2+1);
}

//对编号为index的节点进行中序遍历
void _ldr_show(BinTree* tree,size_t index)
{
	if(index-1>=tree->cal || '#' == tree->arr[index-1]) return;
	//左
	_ldr_show(tree,index*2);
	//根
	printf("%c ",tree->arr[index-1]);	
	//右
	_ldr_show(tree,index*2+1);
}

//对编号为index的节点进行后序遍历
void _lrd_show(BinTree* tree,size_t index)
{
	if(index-1>=tree->cal || '#' == tree->arr[index-1]) return;
	//左
	_lrd_show(tree,index*2);
	//右
	_lrd_show(tree,index*2+1);
	//根
	printf("%c ",tree->arr[index-1]);	
}

//前序遍历
void dlr_show(BinTree* tree)
{
	_dlr_show(tree,1);
	printf("\n");
}

//中序遍历
void ldr_show(BinTree* tree)
{
	_ldr_show(tree,1);	
	printf("\n");
}

//后序遍历
void lrd_show(BinTree* tree)
{
	_lrd_show(tree,1);
	printf("\n");
}


//层序遍历
void layer_show(BinTree* tree)
{
	ListQueue* queue=creat_list_queue();
	push_list_queue(queue,1);	//入编号
	while(!empty_list_queue(queue))
	{
		int index = head_list_queue(queue);
		
		//入左子树
		int left=index*2;
		if(left-1<tree->cal && '#' != tree->arr[left-1])
			push_list_queue(queue,left);
		//入右子树
		int right=index*2+1;
		if(right-1<tree->cal && '#' != tree->arr[right-1])
			push_list_queue(queue,right);
		printf("%c ",tree->arr[index-1]);
		pop_list_queue(queue);

	}
	destroy_list_queue(queue);
	printf("\n");
}

//计算编号index节点的高度
int _high_tree(BinTree* tree,size_t index)
{
	
	if(index-1>=tree->cal || '#' == tree->arr[index-1])
		return 0;
	int left_high=_high_tree(tree,index*2);
	int right_high=_high_tree(tree,index*2+1);
	return left_high>right_high?left_high+1:right_high+1;
}

//树的高度
int high_tree(BinTree* tree)
{
	return _high_tree(tree,1);
}

//计算编号index节点的密度
int _density_tree(BinTree* tree,size_t index)
{
	
	if(index-1>=tree->cal || '#' == tree->arr[index-1])
		return 0;
	return _density_tree(tree,index*2)+_density_tree(tree,index*2+1)+1;
}

//树的密度
int density_tree(BinTree* tree)
{
	return _density_tree(tree,1);
}

//插入
bool insert_tree(BinTree* tree,TREE_TYPE data,TREE_TYPE pdata)
{
	size_t index=1;
	while(index-1<tree->cal)
	{
		if(tree->arr[index-1] == pdata)
		{
			//扩容
			if(index*2-1 >= tree->cal)
			{
				tree->arr=realloc(tree->arr,tree->cal*2*sizeof(TREE_TYPE));
				for(int i=tree->cal;i<tree->cal*2;i++)
					tree->arr[i]='#';
				tree->cal*=2;
			}

			if('#' == tree->arr[index*2-1])
			{
				tree->arr[index*2-1]= data;
				return true;
			}
			else if('#' == tree->arr[index*2])
			{
				tree->arr[index*2]=data;
				return true;
			}
			return false;
		}
		index++;
	}
	return false;
}

//删除叶子节点
bool del_tree(BinTree* tree,TREE_TYPE data)
{
	size_t index=1;
	while(index-1<tree->cal)
	{
		if(data == tree->arr[index-1])
		{
			if(index*2-1<tree->cal && '#'!=tree->arr[index*2-1])
				return false;
			if(index*2<tree->cal && '#'!=tree->arr[index*2])
				return false;
			tree->arr[index-1]='#';
			return true;
		}
		index++;
	}
	return false;
}

//求左
int left_tree(BinTree* tree,TREE_TYPE data)
{
	int index=1;
	while(index-1<tree->cal)
	{
		if(data == tree->arr[index-1])
		{
			if(index*2-1<tree->cal &&'#'!=tree->arr[index*2-1])
			{
				return index*2-1;
			}
			else
			{
				return -1;
			}
		}
		index++;
	}
	return -1;
}

//求右
int right_tree(BinTree* tree,TREE_TYPE data)
{
	int index=1;
	while(index-1<tree->cal)
	{
		if(data == tree->arr[index-1])
		{
			if(index*2<tree->cal && '#'!=tree->arr[index*2])
			{
				return index*2;
			}
			else
			{
				return -1;
			}
		}
		index++;
	}
	return -1;
	
}

//求根
int root_tree(BinTree* tree,TREE_TYPE data)
{
	int index=1;
	while(index-1<tree->cal)
	{
		if(data == tree->arr[index-1])
		{
			return (index-1)/2;
		}
		index++;
	}
	return -1;
	
}

//根据编号显示数据
void index_show_tree(BinTree* tree,size_t index)
{
	if(index>=0 && index<tree->cal)
	{
		printf("%c \n",tree->arr[index]);
	}
	else
	{
		printf("找不到！\n");
	}
}
int main(int argc,const char* argv[])
{
	char* str="ABCD#EFGH##I##J";
	BinTree* tree=creat_tree(str,strlen(str));
	insert_tree(tree,'X','B');
	insert_tree(tree,'Y','J');
	del_tree(tree,'H');
	dlr_show(tree);
	ldr_show(tree);
	lrd_show(tree);
	layer_show(tree);
	printf("high:%d \n",high_tree(tree));
	printf("density:%d \n",density_tree(tree));
	index_show_tree(tree,left_tree(tree,'A'));
}


 

一根葱230
关注
android 时间为第几周,计算当前天是第几周的算法以及小技巧
weixin_39797393的博客
05-30 1021
public static int getWeekOfYear(Stringdate){try{SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");Calendar cal = Calendar.getInstance();//这一句必须要设置，否则美国认为第一天是周日，而我国认为是周一，对计算当期日期是第几周会有错误cal.setFi...
oracle查看日期是第几周,oracle查看日期是第几周-Oracle
weixin_31244759的博客
04-14 2335
oracle查看日期是第几周系统当前时间是多少周，就是是今年的第几个星期www.2cto.comselect to_char(sysdate,’ww’) ,to_char(sysdate,’iw’) from dual;select to_char(sysdate,’ddd’) from dual;select TRUNC(SYSDATE,’MM’) from dual;1)ww的算法为每年1月1...
第六周day03总结
hongqixiaozi的博客
08-28 102
第六周day02总结
hongqixiaozi的博客
08-27 109
第六周day01总结（Vue）
hongqixiaozi的博客
08-26 100
第六周day04总结（Maven）
hongqixiaozi的博客
08-29 127
第六周day05总结（project01）
hongqixiaozi的博客
08-30 340
第五、六周——小结 Day6 8.7
FancySYZ的博客
08-07 186
第五、六周——小结 Day6 8.7
oracle查询一年的第几周,Oracle--计算某一日期为一年中的第几周
weixin_35766308的博客
04-04 2750
selectT31267.CREATED_DATE as F31265,(select to_char(to_date(T31267.CREATED_DATE,'yyyy-mm-dd'),'yyyyiw') from dual) as weekfrom LEAP.HMDM_DM_DLR_CLUE T31267总结：select to_char(TO_DATE('20110101', 'YYYYM...
php计算第几周,PHP计算某时间段内有几个周及某时间为今年第几周 - end
weixin_39669701的博客
03-11 550
...6个月)时，必须满足以下业务要求： 如果end_at早于当前时间，则设置start_at为当前时间，end_at为当前时间加上续买的月数 如果end_at等于或晚于当前时间，则设置end_at=end_at+续买的月数 续买...PHP计算某时间段内有几个周及某时间为今年第几周函数date_default_timezone_set('PRC');function count_wee...
day-planner:GTBC第5周作业
03-16
标题 "day-planner:GTBC第5周作业" 暗示这是一项关于日程计划器的编程作业，可能是某个在线课程（如Google Tech Bootcamp Challenge，GTBC）的第五周任务。作业可能要求学生使用HTML来创建一个交互式或静态的日程...
Python实现获取某天是某个月中的第几周
09-22
3. 在函数中，创建两个datetime对象，一个表示月份的第一天，另一个表示我们要查找的那天。 4. 使用strftime("%W")获取两个日期所在周的周数。 5. 通过计算这两个周数的差值，并加1来得到我们要找的日期是这个月的第...
Week1-Day4:第 1 天第 4 周 - 函数原型
06-11
第 1 天第 4 周 - 函数原型 ##Assignment 概述 在本作业中，您将创建自己的 Git 存储库，并了解对象和函数原型。 为此，您将创建一个非常简单的应用程序，用于记录 Dungeon and Dragons 游戏中玩家和怪物的统计数据...
Week1-Day4:“第 1 天第 4 周 - 函数原型”
06-11
第 1 天第 4 周 - 函数原型 ##Assignment 概述 在本作业中，您将创建自己的 Git 存储库，并了解对象和函数原型。 为此，您将创建一个非常简单的应用程序，用于记录 Dungeon and Dragons 游戏中玩家和怪物的统计数据...
某年第一周开始日期实现方法
09-11
在编程和数据分析中，有时我们需要计算一年中的第一周开始日期，这对于日历系统、报表或者时间统计等场景非常有用。本文将介绍如何实现这个功能，特别是通过SQL Server数据库中的自定义函数来解决这个问题。 首先，...
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 373
【代码】数据结构-线性表-课设实验-手机销售。
【数据结构】双向链表（Doubly Linked List）
最新发布
2301_77727857的博客
10-05 302
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 347
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
动态顺序表的增删改查（数据结构）
m0_62048999的博客
09-28 1213
顺序表是数据结构的基础知识，通过学习次内容，可以让我们了解顺序表中数据中是如何进行存储，删除，插入数据的。
postgresql 判断日期是月份的第几周
05-26
可以使用 PostgreSQL 内置的 `date_trunc()` 和 `extract()` 函数来判断日期是月份的第几周。 具体步骤如下： 1. 使用 `date_trunc()` 函数将日期截断到月份的第一天。 ```sql SELECT date_trunc('month', '2022-05-15'::date); -- 输出结果为：2022-05-01 ``` 2. 使用 `extract()` 函数提取出该日期是星期几，星期日为 0，星期六为 6。 ```sql SELECT extract(dow from '2022-05-15'::date); -- 输出结果为：0 ``` 3. 根据该日期是星期几和月份第一天是星期几的差值，计算出该日期是该月的第几周。注意，因为 PostgreSQL 中向下取整，所以需要加 1。 ```sql SELECT ceil((extract(day from '2022-05-15'::date) + extract(dow from '2022-05-15'::date) - 1) / 7.0); -- 输出结果为：3 ``` 因此，'2022-05-15' 是 2022 年 5 月的第 3 周。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值