二叉树的构建与遍历（C语言）

最新推荐文章于 2024-04-29 11:00:46 发布
最新推荐文章于 2024-04-29 11:00:46 发布
阅读量4k 收藏 61
点赞数 7
文章标签： c语言 数据结构 visual studio 递归算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Enthusiastic_boy/article/details/121865417
版权

目录

一、二叉树的存储结构

二、二叉树的遍历

三.节点个数以及高度

四、构建二叉树

五：完整代码

一、二叉树的存储结构

1.顺序存储：

顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空 间的浪费。而现实中使用中只有堆才会使用数组来存储。二叉树顺 序存储在物理上是一个数组，在逻辑上是一颗二叉树。

2.链式存储

二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是 链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。 

下面主要来讲 链式存储 的二叉树。所以得先用结构体来表示二叉树单个节点的结构： 
typedef int DataType;
typedef struct BinaryTreeNode{
	DataType data;
	struct BinaryTreeNode* left;//左孩子节点的地址
	struct BinaryTreeNode* right;//右孩子节点的地址
}BTNode;

二、二叉树的遍历

用递归的方式创建二叉树的过程比较抽象，所以先来讲二叉树的遍历（前、中、后）序。现在有下图的二叉树，我们依次来遍历此二叉树 ：

1. 前序遍历 —— 访问根结点的操作发生在遍历其左右子树之前。
在下面代码中打印出节点的data值就是遍历该节点，前序遍历代码如下： 
void PreOrder(BTNode* root){//前序遍历
	if (root == NULL){//空树就返回
		return;
	}
	printf("%d ", root->data);//打印当前节点的data值
	PreOrder(root->left);//遍历左子树
	PreOrder(root->right);//遍历右子树
}
上面的代码中，root为指向根节点的指针（根节点是值为1的节点）。下面继续用图像的形式来直观的上述代码的执行流程：

 所以前序遍历的结果为：1，2，3，4，5，6

2. 中序遍历 —— 访问根结点的操作发生在遍历其左右子树之中（间）。
中序遍历的代码只需要在前序遍历的代码上稍稍修改就好： 
void InOrder(BTNode* root){//中序遍历
	if (root == NULL){
		return;
	}
	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}

那么中序遍历的结果为：3，2，1，5，4，6

3. 后序遍历 —— 访问根结点的操作发生在遍历其左右子树之后。 
void PostOrder(BTNode* root){//后序遍历
	if (root == NULL){
		return;
	}
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);
}

后序遍历的结果为：3，2，5，6，4，1

三.节点个数以及高度

1.二叉树节点个数

int BinaryTreeSize(BTNode* root){//二叉树节点数
	if (root == NULL){//空树直接返回0
		return 0;
	}
	return BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
}

以上代码也是递归，求出左子树的节点个数和右子树的节点个数，把他们加起来就是最终结果。加1指的是加上当前节点。

2.二叉树叶子节点的个数

int BinaryTreeLeafSize(BTNode* root){//叶子节点数
	if (root == NULL){//空树直接返回0
		return 0;
	}
	if (root->left == NULL&&root->right == NULL){//满足条件，说明遇到了叶子节点，返回1
		return 1;
	}
	return  BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}

求叶子节点个数，关键在于判定当前节点是否为叶子节点，如果是则 返回1。

3.第k层节点个数（默认根节点为第一层）

int BinaryTreeLevelKSize(BTNode* root, int k){//第k层节点个数
	if (root == NULL || k < 1){//空树或者k不合法，直接返回0
		return 0;
	}
	if (k == 1){//当前的某一个节点
		return 1;
	}
	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}

用直观的一幅图来理解上述代码：

 

 当想要求二叉树的第K层节点个数时，可以把问题转化成求其左右子树的第K-1层的节点个数，递归出口为root==NULL或当K==1时返回1，那么就求出了第K层节点个数。

4.二叉树的深度（只有一个节点那么深度是1）

int Depth(BTNode* root){//计算树的深度
	if (root == NULL){//无左右子树直接返回0
		return 0;
	}
	int leftdepth=Depth(root->left) + 1;//求其左子树深度
	int rightdepth = Depth(root->right) + 1;//求其右子树深度
	return leftdepth > rightdepth ? leftdepth : rightdepth;
}

将问题转化为求左右子树的深度，但是函数的返回值只有一个，返回值为左右子树中最深的树的深度。注意递归出。

5.查找某个节点

BTNode* BinaryTreeFind(BTNode* root, DataType x){//查找某个节点
	if (root == NULL){
		return NULL; 
	}
	if (root->data == x){
		return root;
	}
	BTNode* ret=BinaryTreeFind(root->left, x);
	if (ret){
		return ret;//找到了直接返回，就不用在遍历其右子树
	}
	return BinaryTreeFind(root->right, x);
}

用前序遍历的思想来创建二叉树，树为空，直接返回。先判断当前节点的值是否是要查找的值，如果不是，那么遍历其左子树，一旦找到就返回当前节点的地址。注意：在返回其左子树查找的结果时，要判断当前结果是否为空，如果是空，说明没有找到，那么还需要在右子树中去查找。

四、构建二叉树

链式存储的二叉树需要在堆上申请空间，所以先给出申请单个节点的代码：

BTNode* BuyNode(DataType x){
	BTNode* node = (BTNode *)malloc(sizeof(BTNode));
	if (node == NULL){
		perror("malloc");
		exit(0);
	}
	node->left = NULL;
	node->right = NULL;
	node->data = x;
	return node;
}

默认把单个节点的left和right的值置为NULL，返回值为创建好的节点的地址。

构建二叉树时需要用到前序遍历的思想，就是先创建根节点，然后在创建其左右子树。假如要创建如下图的二叉树：

首先会得到二叉树中的值为：1 2 3 4 5 6，那么此时需要用数组将这些值保存起来，例如：

DataType arr[] = { 1, 2, 3,4, 5,6};

这时，如果用前序遍历(递归)的思想来创建这颗树，那么会发现根本找不到递归出口，无法创建。那么得找到那个递归的出口，现在可以把要创建的二叉树假想成下图的样子：

 对二叉树进行补充，补充上无效值0，那么保存二叉树值的数组变成：

DataType arr[] = { 1, 2, 3, 0, 0, 0, 4, 5, 0, 0, 6 ，0，0};

此时递归出口就是碰到无效值退出。先上代码：


BTNode* _CreatBinaryTree(DataType* arr, int size, DataType invalid, int *subscript){//创建二叉树
	if (*subscript < size&&arr[*subscript]!=invalid){//当没有越界或者没有碰到无效值就执行下面的代码
		BTNode* root = BuyNode(arr[*subscript]);//创建当前根节点
		(*subscript)++;//相当于数组下标加1
		root->left = _CreatBinaryTree(arr, size, invalid, subscript);//创建左子树
		(*subscript)++;
		root->right = _CreatBinaryTree(arr, size, invalid, subscript);
		return root;
	}
	return NULL;
}

此时代码有四个参数，第一个参数为：数组的首地址，第二个参数为：数组此时包含的元素个数，第三个参数为：数组中的无效值（可更改），第四个参数是一个变量的地址，这个变量初始值为0，代表数组元素的下标。

利用前序遍历的思想，在每次调用函数时就把当前根节点创建好，然后在创建其左右子树，需要注意的是：每次创建左右子树时数组的下标需要加1，所以才有了变量subscript，每次进行传递地址，以保证数组的下标在不断加1（也可以定义一个全局变量，此时就不用传递地址了）。递归结束条件为：碰到无效值0或者下标大于数组合法下标。

五：完整代码

1.BinaryTreeNode.h

#pragma once
#include <stdio.h>
#include <windows.h>
#include <assert.h>
typedef int DataType;
typedef struct BinaryTreeNode{
	DataType data;
	struct BinaryTreeNode* left;//左孩子节点的地址
	struct BinaryTreeNode* right;//右孩子节点的地址
}BTNode;
extern BTNode* CreatBinaryTree(DataType* arr, int size, DataType invalid);
extern void PreOrder(BTNode* root);
extern void InOrder(BTNode* root);
extern void PostOrder(BTNode* root);
extern int BinaryTreeSize(BTNode* root);
extern int BinaryTreeLeafSize(BTNode* root);
extern int BinaryTreeLevelKSize(BTNode* root, int k);
extern BTNode* BinaryTreeFind(BTNode* root, DataType x);
extern int Depth(BTNode* root);
extern void BinaryTreeDestory(BTNode** root);

2.BinaryTreeNode.c

#include "BinaryTreeNode.h"
BTNode* BuyNode(DataType x){
	BTNode* node = (BTNode *)malloc(sizeof(BTNode));
	if (node == NULL){
		perror("malloc");
		exit(0);
	}
	node->left = NULL;
	node->right = NULL;
	node->data = x;
	return node;
}
BTNode* _CreatBinaryTree(DataType* arr, int size, DataType invalid, int *subscript){//创建二叉树
	if (*subscript < size&&arr[*subscript]!=invalid){//当没有越界或者没有碰到无效值就执行下面的代码
		BTNode* root = BuyNode(arr[*subscript]);//创建当前根节点
		(*subscript)++;//相当于数组下标加1
		root->left = _CreatBinaryTree(arr, size, invalid, subscript);//创建左子树
		(*subscript)++;
		root->right = _CreatBinaryTree(arr, size, invalid, subscript);
		return root;
	}
	return NULL;
}
BTNode * CreatBinaryTree(DataType* arr, int size, DataType invalid){//创建二叉树
	int subscript = 0;//可以理解为数组下标
	return _CreatBinaryTree(arr, size, invalid, &subscript);
}
void PreOrder(BTNode* root){//前序遍历
	if (root == NULL){//空树就返回
		return;
	}
	printf("%d ", root->data);//打印当前节点的data值
	PreOrder(root->left);//遍历左子树
	PreOrder(root->right);//遍历右子树
}
void InOrder(BTNode* root){//中序遍历
	if (root == NULL){
		return;
	}
	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}
void PostOrder(BTNode* root){//后序遍历
	if (root == NULL){
		return;
	}
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);
}
int BinaryTreeSize(BTNode* root){//二叉树节点数
	if (root == NULL){//空树直接返回0
		return 0;
	}
	return BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
}
int BinaryTreeLeafSize(BTNode* root){//叶子节点数
	if (root == NULL){//空树直接返回0
		return 0;
	}
	if (root->left == NULL&&root->right == NULL){//满足条件，说明遇到了叶子节点，返回1
		return 1;
	}
	return  BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}
int BinaryTreeLevelKSize(BTNode* root, int k){//第k层节点个数
	if (root == NULL || k < 1){//空树或者k不合法，直接返回0
		return 0;
	}
	if (k == 1){//当前的某一个节点
		return 1;
	}
	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}
BTNode* BinaryTreeFind(BTNode* root, DataType x){//查找某个节点
	if (root == NULL){
		return NULL; 
	}
	if (root->data == x){
		return root;
	}
	BTNode* ret=BinaryTreeFind(root->left, x);
	if (ret){
		return ret;//找到了直接返回，就不用在遍历其右子树
	}
	return BinaryTreeFind(root->right, x);
}
int Depth(BTNode* root){//计算树的深度
	if (root == NULL){
		return 0;
	}
	int leftdepth=Depth(root->left) + 1;//求其左子树深度
	int rightdepth = Depth(root->right) + 1;//求其右子树深度
	return leftdepth > rightdepth ? leftdepth : rightdepth;
}
void BinaryTreeDestory(BTNode** root){//销毁二叉树
	assert(root);
	if (*root == NULL){
		return;
	}
	BinaryTreeDestory(&(*root)->left);
	BinaryTreeDestory(&(*root)->right);
	free(*root);
	*root = NULL;
}

3.main.c

#include "BinaryTreeNode.h"
int main(){
	DataType arr[] = { 1, 2, 3, 0, 0, 0, 4, 5, 0, 0, 6 };
	BTNode* root = CreatBinaryTree(arr,sizeof(arr)/sizeof(arr[0]),-1);
	PreOrder(root);
	printf("\n");
	InOrder(root);
	printf("\n");
	PostOrder(root);
	printf("\n");
	printf("二叉树节点个数为:%d\n", BinaryTreeSize(root));
	printf("二叉树叶子节点个数为:%d\n", BinaryTreeLeafSize(root));
	printf("二叉树第3层节点个数为:%d\n", BinaryTreeLevelKSize(root,3));
	printf("二叉树深度为:%d\n", Depth(root));
	BinaryTreeDestory(&root);
	system("pause");
	return 0;
}

Enthusiastic_boy
关注
  • 7
    点赞
  • 踩
  • 61
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
C语言实现二叉树的创建遍历
05-05
利用递归方式完成二叉树的简单创建以及遍历。
C语言二叉树的创建与遍历
le123didi的博客
10-09 9087
二叉树（binary tree）是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。以下是对链式存储结构的二叉树的创建与先序、中序、后序遍历操作。
二叉树及遍历
moonshadow44的博客
05-24 604
二叉树的遍历一、二叉树的初始化和赋值1、定义二叉树2、引入队列3、初始化4、入栈和出栈5、用给定字符建立结点6、用给定字符创立二叉树二、四种遍历1、层次遍历2、前序遍历3、中序遍历4、后序遍历三、总代码四、测试结果 一、二叉树的初始化和赋值 1、定义二叉树 用结构体定义二叉树 typedef struct BTNode{ char element; BTNode* left; BTNode* right; }BTNode, *BTNodePtr; 2、引入队列 typedef struct BTNo
二叉树的创建及三种遍历输出的代码实现
m0_57080477的博客
02-15 581
这里介绍一下递归的创建方式。
数据结构 C 二叉树的构建与遍历
qq_66967137的博客
05-24 651
二叉树的存储结构 顺序存储仅适合完全二叉树，其他类型适合用链式存储 1.二叉树的二叉链式存储表示 typedef struct BTNode{ char element; struct BTNode* leftChild; struct BTNode* rightChild; }BTNode,*BTNodePtr; 2.二叉树队列的表示 typedef struct BTNodeQueue{ BTNodePtr* nodePtrs; //队列里存放的是二叉...
（九）二叉树的建立与遍历方法（c语言）（附代码与调试）
qq_52608074的博客
09-04 2192
一.二叉树 首先我们聊一聊什么是二叉树，二叉树就是n个节点的有限集合，该集合或者空集（称为空二叉树），或者由一个根节点和两课互不相交的分别称为根节点的左子树和右子树的二叉树组成。 一看这，嗨哟，挺复杂，其实我们只要抓住它的特点就行了，二叉树嘛，①他的每个节点最多有两颗子树，我们可以理解为二胎政策，一个家庭最多有两个孩子，②很重要的一个就是他的左右子树是有顺序的，不能颠倒，这个我们可以理解为家里的两个孩子，一个是哥哥，一个是弟弟，哥哥和弟弟不能混淆，③树中有一颗子树也要区分它是左子树还是右子树，这个和后面讲的
建立一个二叉树及遍历二叉树的步骤(C语言)
qq_49175846的博客
05-19 9437
建立一个简单二叉树的基本步骤
二叉树的构建与遍历（先序、中序、后序、层次）
轻舟终过万重山
01-14 7619
二叉树的构建与遍历
二叉树的创建以及遍历
qq_51725723的博客
07-21 2151
**二叉树的存储方式有两种，一种是以链表的方式进行存储，一种是以数组的方式进行存储*当以数组的方式进行存储的时候，要注意节点之间的关系，假设根节点的位置为POS那么左子树的位置就是*2*POS+1，右子树的位置就是2*POS+2。正是由于这层关系，当二叉树不是满二叉树的时候，使用数组进行存储*是非常的浪费空间的，空间的利用率较低。*当以链表的方式存储二叉树的时候，每一个二叉树节点都含有一个左孩子指针和一个右孩子指针，两个指针分别*指向相应的节点，节省空间，并且更容易使用。*/...
【数据结构入门实验】二叉树的建立和遍历完整代码
亿维数组's博客
05-22 3464
实验内容： 1．二叉树的建立与遍历（验证性实验） 问题描述 建立一棵二叉树，并对其进行遍历（先序、中序和后序），打印输出遍历结果。 基本要求 从键盘接受输入（先序），以二叉链表作为存储结构，建立二叉树（以先序来建立），并采用递归 算法对其进行遍历（先序、中序和后序），将遍历结果打印输出。 测试数据 ABC□□DE□G□□F□□□（其中□表示空格字符），则输出结果为：先序为ABCDEGF，中序为 CBEGDFA， z 后序为CGBFDBA。 实验分析： 实验要求
【数据结构】二叉树的创建及遍历（C语言实现）
一个学生の乱记
04-10 1315
1. 当前要创建的节点值为'#'，并且flag=1，说明当前节点的父节点的左右孩子已经创建完毕，应将栈顶元素出栈，如果出栈的元素与栈顶的元素的右孩子相同，说明当前节点的父节点的左右孩子也创建完毕。首先，我们对二叉树进行扩展，然后按先序遍历的顺序输入节点的信息，然后我们设置一个标志位flag，如果flag=0，创建当前节点的左孩子节点，当flag=1时，创建当前节点的右孩子节点。2. 当前要创建的节点值'#'，并且flag=0，说明当前节点的父节点的左孩子已经创建完毕，转向创建右孩子，把flag置为1；
二叉树的创建与遍历
kashine的博客
12-10 3559
二叉树有多种不同的遍历方法，比如先序遍历（preorder traversal）、中序遍历（inorder traversal）和后序遍历（postorder traversal）。例如，先序遍历通常用于复制一棵二叉树，中序遍历通常用于排序，后序遍历通常用于计算一棵二叉树的高度。
二叉树的构建及遍历操作
07-27
二叉树的所有基本操作 源代码 自己重新编译一次
C语言实现二叉树遍历的迭代算法
12-25
本文实例讲述了C语言实现二叉树遍历的迭代算法，是数据结构算法中非常经典的一类算法。分享给大家供大家参考。 具体实现方法如下： 二叉树中序遍历的迭代算法： #include #include using namespace std; struct ...
c语言_构建一个静态二叉树实现方法
12-31
第一、树的构建 定义树结构 struct BTNode { char data; struct BTNode* pLChild; struct BTNode* pRChild; }; 静态方式创建一个简单的二叉树 struct BTNode* create_list() { struct BTNode* pA = (struct ...
二叉树遍历序列还原
12-08
给出二叉树的中序遍历序列和后序遍历序列，编程还原该二叉树。 输入： 　第1行为二叉树的中序遍历序列 　第2行为二叉树的后序遍历序列 输出： 　二叉树的按层遍历序列
C语言如何⽤指针为函数传递数组？
PAP
04-25 311
C语言如何⽤指针为函数传递数组？
手搓数组栈（C语言）
最新发布
m0_62646213的博客
04-29 283
用C语言实现数组结构的栈
C语言----链表
2302_80318761的博客
04-23 781
那么大家知道创建一个链表节点如同火车要先把壳造出来，然后在天东西进去，那么我们要先定义好节点的“壳”。那么我们先创建一个头文件Slist.h和源文件Slist.c。一个是定义数据的，讲文明需要用到的库函数的头文件全部放进去。然后需要定义的东西也放进去。那么我们肯定还需要一个实现代码的文件，那么我们再创建一个源文件text.h。来实现我们的代码。好但我们创建好了这些前置条件后，那么我们就来看看这个单链表的定义。大家先看我们的主要知识，我们说单链表里面除了存放的内容外就是下一个节点的地址了。那么简单呀。
二叉树的层序遍历c语言
09-08
二叉树的层序遍历可以使用队列来实现。具体步骤如下： 1. 定义一个队列，用于存储待访问的节点。 2. 将根节点入队。 3. 循环执行以下操作，直到队列为空： - 弹出队首节点，并访问该节点。 - 如果该节点有左子节点，则将左子节点入队。 - 如果该节点有右子节点，则将右子节点入队。 4. 遍历结束。 下面是一个示例的C语言代码实现： ```c #include <stdio.h> #include <stdlib.h> // 定义二叉树节点结构 typedef struct TreeNode { int val; // 节点值 struct TreeNode* left; // 左子节点指针 struct TreeNode* right; // 右子节点指针 } TreeNode; // 定义队列节点结构 typedef struct QueueNode { struct TreeNode* data; // 队列节点数据 struct QueueNode* next; // 下一个队列节点指针 } QueueNode; // 定义队列结构 typedef struct Queue { QueueNode* front; // 队头指针 QueueNode* rear; // 队尾指针 } Queue; // 初始化队列 void initQueue(Queue* queue) { queue->front = NULL; queue->rear = NULL; } // 入队操作 void enqueue(Queue* queue, TreeNode* data) { QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode)); newNode->data = data; newNode->next = NULL; if (queue->rear == NULL) { queue->front = newNode; queue->rear = newNode; } else { queue->rear->next = newNode; queue->rear = newNode; } } // 出队操作 TreeNode* dequeue(Queue* queue) { if (queue->front == NULL) { return NULL; } QueueNode* temp = queue->front; TreeNode* data = temp->data; queue->front = queue->front->next; if (queue->front == NULL) { queue->rear = NULL; } free(temp); return data; } // 层序遍历 void levelOrderTraversal(TreeNode* root) { if (root == NULL) { return; } Queue queue; initQueue(&queue); enqueue(&queue, root); while (queue.front != NULL) { TreeNode* node = dequeue(&queue); printf("%d ", node->val); if (node->left != NULL) { enqueue(&queue, node->left); } if (node->right != NULL) { enqueue(&queue, node->right); } } } int main() { // 构建二叉树 TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode)); root->val = 1; TreeNode* node2 = (TreeNode*)malloc(sizeof(TreeNode)); node2->val = 2; TreeNode* node3 = (TreeNode*)malloc(sizeof(TreeNode)); node3->val = 3; TreeNode* node4 = (TreeNode*)malloc(sizeof(TreeNode)); node4->val = 4; TreeNode* node5 = (TreeNode*)malloc(sizeof(TreeNode)); node5->val = 5; root->left = node2; root->right = node3; node2->left = node4; node2->right = NULL; node3->left = NULL; node3->right = node5; node4->left = NULL; node4->right = NULL; node5->left = NULL; node5->right = NULL; // 层序遍历 levelOrderTraversal(root); return 0; } ``` 上述代码中，首先定义了二叉树节点结构和队列节点结构，并初始化了队列。然后，使用队列实现层序遍历的核心部分。最后，在主函数中构建了一个示例二叉树，并调用层序遍历函数进行输出。

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值