C语言-实现顺序二叉树和平衡二叉树AVL

已于 2023-04-10 22:03:45 修改
阅读量1k 收藏 11
点赞数 1
分类专栏： C/ C++ 编程知识 文章标签： c语言 算法 数据结构 二叉树 平衡二叉树
于 2023-04-10 21:44:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40587575/article/details/130070369
版权

1. 结构体

在实现二叉树之前先看下结构体的一些使用方法

数组是保存一系列相同的数据。在实际问题中，一组数据往往有很多种不同的数据类型。例如，登记学生的信息，可能需要用到 char型的姓名，int型或 char型的学号，int型的年龄

///第一种方式
struct Person{
    int age;
    char name[20];
};
//之后定义变量
struct Person a, b;
 
///第二种方式（声明的同时定义）
struct Person {
    int age;
    char name[20];
}a, b;
 
///第三种方式（不需要提供结构体名字，直接定义）
struct {
    int age;
    char name[20];
}a, b;

访问结构成员

访问其中的各个元素，用结构成员运算符点（.）。即访问成员的一般形式是：结构变量名 . 成员名
如 a.name 表示学生 a 的姓名。

结构成员的初始化

1）结构体的成员逐个赋值

struct Person stu1;      //定义结构体变量
strcpy(stu1.name, "Jack");
stu1.age= 18;

2）整体赋值

struct Person stu1 = {"jack", 12};

也可以在初始化的时候赋值

struct Person {                 //声明结构体 Person
    char name[20];               
    int age;                   
}stu = {"Mike", 20};        //注意初始化值的类型和顺序要与结构体声明时成员的类型和顺序一致

也可以按照任意的顺序使用指定初始化：

struct Person st = { .name = "Smith",
                          .age= 18 };

3）整体拷贝

struct Person stu1 = {"jack_mike", 12};
struct Person stu2;
stu2 = stu1;

如上每次使用结构体均需要写struct，可以使用typedef 简化书写

typedef struct Person {
    char name[20];
    int age;
}Person;
// 定义一个结构体
    Person stu1 = {"jack", 12};

结构成员指针

结构变量作为函数的参数传递时，将整个结构体变量拷贝为副本，传送的空间开销比较大，特别是当成员有数组的时候，程序效率较低。所以可以考虑使用结构体指针。

通过结构指针间接访问成员值:

访问的一般形式：
（*结构指针变量）. 成员名 或 结构指针变量 -> 成员名

typedef struct Person {
    char name[20];
    int age;
}Person;

int main(){
    Person stu1 = {"jack", 12};
    Person* stuP = &stu1;
// (*stuP).name
    printf("Person name: %s \n", (*stuP).name);
//  stuP->name
    printf("Person name: %s \n", stuP->name);

    return 0;
}

2. 二叉树

2-1）树的基本概念

  • 节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A的为6
  • 叶节点或终端节点：度为0的节点称为叶节点； 如上图：B、C、H、I…等节点为叶节点
  • 非终端节点或分支节点：度不为0的节点； 如上图：D、E、F、G…等节点为分支节点
  • 双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点； 如上图：A是B的父节点
  • 孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点； 如上图：B是A的孩子节点
  • 兄弟节点：具有相同父节点的节点互称为兄弟节点； 如上图：B、C是兄弟节点
  • 树的度：一棵树中，最大的节点的度称为树的度； 如上图：树的度为6
  • 节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
  • 树的高度或深度：树中节点的最大层次； 如上图：树的高度为4
  • 堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为兄弟节点
  • 节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先
  • 子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙
  • 森林：由m（m>0）棵互不相交的树的集合称为森林；

二叉树

二叉树是由一个根节点加上两棵别称为左子树和右子树的二叉树组成；二叉树不存在度大于2的结点

2-2）二叉树的创建与递归遍历

依据前序遍历建二叉树，树结构如上图所示：

参数是二级指针时，需要传入左节点的地址，需要改变指针的指向

#include <stdio.h>
#include <stdlib.h>
 
typedef struct treeNode{
    struct treeNode* left;
    struct treeNode* right;
    char data;
}treeNode;
 
treeNode* mallocTreeNode(char data){
    treeNode* node = (treeNode*)malloc(sizeof(treeNode));
    node->data = data;
    return node;
}
 
// 使用递归的方法创建一棵二叉树，不用return 这里使用二级指针
void createTree(treeNode** node, char* src, int* index){
    char ch = *(src + *index);
    (*index)++;
    printf("ch is %c \n", ch);
    if (ch != '#'){
        // 根左右，前序遍历二叉树
        *node = mallocTreeNode(ch);
        createTree(&((*node)->left), src, index);
        createTree(&((*node)->right), src, index);
    }else{
        *node = NULL;
    }
}
 
treeNode* createTree2(char* src, int* index){
    char ch = *(src + *index);
    (*index)++;
    printf("ch is %c \n", ch);
    if (ch != '#'){
        // 根左右，前序遍历二叉树
        treeNode* node = mallocTreeNode(ch);
        node->left = createTree2(src, index);
        node->right = createTree2(src, index);
        return node;
    }
    return NULL;
}

main 函数

int main(){
    printf("this is binary tree test =====\n");
    char* src = "ABD##E##C##";
    // Node* root = create_tree();
    treeNode* root = NULL;
    int index = 0;
    // createTree(&root, src, &index);
    root = createTree2(src, &index);
    printf("root left= %c \n", root->left->data);
 
    return 0;
}

递归遍历二叉树：前序遍历、中序遍历、后续遍历

// 前序遍历二叉树: 中左右
void printPreOrderTree(treeNode* root){
    if (root != NULL){
        printf(" %c - ", root->data);
        printPreOrderTree(root->left);
        printPreOrderTree(root->right);
    } 
}
 
// 中序遍历二叉树: 左中右
void printInOrderTree(treeNode* root){
    if (root != NULL){
        printInOrderTree(root->left);
        printf(" %c - ", root->data);
        printInOrderTree(root->right);
    } 
}
 
// 后序遍历二叉树: 左右中
void printBackOrderTree(treeNode* root){
    if (root != NULL){
        printBackOrderTree(root->left);
        printBackOrderTree(root->right);
        printf(" %c - ", root->data);
    } 
}

二叉树的非递归遍历可以看这篇博文

5-3）顺序二叉树

顺序二叉树的中序遍历是有顺序的。

#include <stdio.h>
#include <stdlib.h>
 
typedef struct treeNode{
    struct treeNode* left;
    struct treeNode* right;
    int data;
}treeNode;
 
treeNode* mallocTreeNode(int data){
    treeNode* node = (treeNode*)malloc(sizeof(treeNode));
    node->data = data;
    return node;
}
 
// 中序遍历二叉树: 左中右
void printInOrderTree(treeNode* root){
    if (root != NULL){
        printInOrderTree(root->left);
        printf(" %d - ", root->data);
        printInOrderTree(root->right);
    } 
}
 
// 由于需要改变头部节点的值 // -> 运算符优先级比 & 大
void orderedTreeInsert(treeNode** node, int data){
    if(*node == NULL){
        *node = mallocTreeNode(data);
        (*node)->left = NULL;
        (*node)->right = NULL;
    }else if (data > (*node)->data ){
        
        orderedTreeInsert(&(*node)->right, data);
    }else if(data < (*node)->data){
        orderedTreeInsert(&(*node)->left, data);
    }else{
        // 如果2 个值相等，则不插入，忽略
        return;
    }
}
 
// 需要找到最底层的 node 先free，然后一直往上递归。类似于后序遍历。左右根
void freeNode(treeNode** node){
    if (*node != NULL){
        freeNode(&(*node)->left);
        freeNode(&(*node)->right);
        printf("free node: %d \n", (*node)->data);
        free(*node);
        *node = NULL;
    }
}
 
int main(){
    printf("this is ordered tree == \n");
    const int SIZE = 7;
    int data[7] = {4, 6, 3, 7, 2, 9, 1};
    treeNode* root = NULL;
    for (int i=0; i< SIZE; i++){
        orderedTreeInsert(&root, data[i]);
    }
    printInOrderTree(root);
    printf("\n");
    freeNode(&root);
 
    return 0;
}

main函数创建顺序二叉树

int main(){
    int data[7] = {4, 6, 3, 7, 2, 9, 1};
    int size= sizeof(data) / sizeof(int);
    treeNode* root = NULL;
    for (int i=0; i< size; i++){
        orderedTreeInsert(&root, data[i]);
    }
    printInOrderTree(root);
    printf("\n");
    freeNode(&root);
 
    return 0;
}

5-4）二叉平衡树 AVL 树

二叉排序树可以在一定程度上提高查找（搜索）的效率，但仍然会出现特殊情况，让二叉排序树失效。例如，将序列{1,2,3,4,5,6, 7}中的元素依次插入到二叉排序树中，会得到右斜树，这就相当于一个单链表了，搜索效率降低为O(n)。

上述的二叉排序树输出的中序遍历和后续遍历的值为如下，可以看出退化成了一个链表了。

1 -  2 -  3 -  4 -  5 -  6 -  7 - 
back print 
 7 -  6 -  5 -  4 -  3 -  2 -  1 -

平衡二叉树的性质：

  • 可以是空树。
  • 假如不是空树，任何⼀个结点的左子树与右子树都是平衡⼆叉树，并且 高度之差的绝对值不超过 1 。

二叉平衡树的构建

  1. 首先判断当前节点的值与插入的节点值的大小，递归插入到左、右节点中
  2. 如果是插入到右节点，先判断左右子树是否是平衡的，如果不平衡的话，则判断如下：
  • -1）如果当前插入的值大于节点的右节点值的话，则表示是 RR形式的，需要左旋
  • -2）如果当前插入的值小于节点的右节点值的话，则表示是 RL 形式的，先对当前节点的右节点进行右旋，更新节点，再对根部节点左旋。
  1. 如果是插入到左节点，先判断左右子树是否是平衡的，如果不平衡的话，则判断如下：
  • -1）如果当前插入的值小于节点的左节点值的话，则表示是 LL 形式的，需要右旋
  • -2）如果当前插入的值大于于节点的左节点值的话，则表示是 LR 形式的，先对当前节点的左节点进行左旋，更新节点，再对根部节点右旋。

RR形式，左旋


void RRrotation(treeNode* node, treeNode** root){
    // 缓存 tmp，因为tmp 会最终作为新的头部节点
    treeNode* tmp = node->right;
    node->right = tmp->left;
    tmp->left = node;
    // 更新tmp 和 node 的节点的高度
    node->height = MAX(getTreeHeight(node->left), getTreeHeight(node->right)) + 1;
    tmp->height = MAX(getTreeHeight(tmp->left), getTreeHeight(tmp->right)) + 1;
    // 更新根部节点
    *root = tmp;

LL形式，右旋

void LLrotation(treeNode* node, treeNode** root){
    treeNode* tmp = node->left;
    node->left = tmp->right;
    tmp->right = node;
    node->height = MAX(getTreeHeight(node->left), getTreeHeight(node->right)) + 1;
    tmp->height = MAX(getTreeHeight(tmp->left), getTreeHeight(tmp->right)) + 1;
    // 更新根部节点
    *root = tmp;
}

右孩子的左子树 RL

右孩子的左子树 插入导致失衡

左孩子的右子树 LR

左孩子的右子树 插入导致失衡

#include <stdio.h>
#include <stdlib.h>
 
#define MAX(a, b) ((a > b) ? (a) : (b))
 
typedef struct treeNode{
    struct treeNode* left;
    struct treeNode* right;
    int height;
    int data;
}treeNode;
 
treeNode* mallocTreeNode(int data){
    treeNode* node = (treeNode*)malloc(sizeof(treeNode));
    node->data = data;
    node->height = 0;
    return node;
}
 
int getTreeHeight(treeNode* node){
    return node ? node->height : 0;
}
 
void avlTreeInsert(treeNode** node, int data){
    if (*node == NULL){
        *node = mallocTreeNode(data);
        (*node)->left = NULL;
        (*node)->right = NULL;
    }else if(data > (*node)->data){
        // 如果插入的节点要大于当前的节点,插入到右节点
        avlTreeInsert(&(*node)->right, data);
        // 再对节点进行旋转
        int leftHeight = getTreeHeight((*node)->left);
        int rightHeight = getTreeHeight((*node)->right);
        // 如果是左右子树是不平衡的树
        if (rightHeight-leftHeight == 2){
            // 如果当前节点还大于右边最大的节点，则进行左旋
            // 找到首个节点即可。
            if (data > (*node)->right->data){
                RRrotation(*node, node);
            }else{
                // RL 形式的树，先对node->right 节点右旋，然后对node 左旋
                RRrotation((*node)->right, &(*node)->right);
                LLrotation(*node, node);
            }
        }
    }else if(data < (*node)->data){
        avlTreeInsert(&(*node)->left, data);
        int leftHeight = getTreeHeight((*node)->left);
        int rightHeight = getTreeHeight((*node)->right); 
        if (leftHeight-rightHeight == 2){
            if (data < (*node)->left->data){
                // LL 形式节点
                LLrotation(*node, node);
            }else{
                // LR 形式的树，先对node->left 节点左旋，然后对更新后的node 节点右旋
                LLrotation((*node)->left, &(*node)->left);
                RRrotation(*node, node);
            }
        }       
    }else{
        return;
    }
    (*node)->height = MAX(getTreeHeight((*node)->left), getTreeHeight((*node)->right)) + 1;
}
 
void orderPrintTree(treeNode* root){
    if (root != NULL){
        // 中序遍历: 左根右
        orderPrintTree(root->left);
        printf(" -%d ", root->data);
        orderPrintTree(root->right);
    }
}
 
void printBackOrderTree(treeNode* root){
    if (root != NULL){
        printBackOrderTree(root->left);
        printBackOrderTree(root->right);
        printf(" %d - ", root->data);
    } 
}
 
 
int main(){
 
    int arr[] = {1, 2, 3, 4, 5, 6, 7};
    int size = sizeof(arr) / sizeof(int);
    treeNode* root = NULL;
    for (int i=0; i< size; i++){
        avlTreeInsert(&root, arr[i]);
    }
    orderPrintTree(root);
    printf("back order === \n");
    printBackOrderTree(root);
 
    return 0;
}

二叉平衡树的搜索的时间复杂度为 O(log2n)

二叉平衡树博客惨参考

蜘蛛侠不会飞
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构_平衡二叉树(C语言)
小黯
06-22 535
平衡二叉树
C语言实现平衡二叉树
weixin_45859193的博客
08-19 2346
文章目录前言一、平衡二叉树实现原理二、平衡二叉树实现算法三、全部代码 前言 对于判断是否为平衡二叉树而言，我们需要知道以下特性： 是一个二叉树 也是一个二叉排序树 该树的每个结点上的(深度)左子树 - 右子树的值为平衡因子(BF(Balance Factor)) 该树的每一个节点的左子树和右子树的高度至多等于1(平衡因子只可能是-1，0，1) 对于一个二叉排序树而言，它们的结构都是根据了二叉树的特性从最左子树开始在回到该结点上继续往右结点走，通过该方式进行递归操作，并且该二叉排序树的结构也是从小到大依
三：二叉树的初始化操作及应用
@76135327的博客
11-20 2862
内容链式存储结构初始化空二叉树 InitBiTree(&T)销毁二叉树 DestroyBiTree(&T)创建二叉树 CreateBiTree(&T, definition)清空二叉树 ClearBiTree(&T)判断空二叉树 BiTreeEmpty(T)求二叉树深度 BiTreeDepth(T)求双亲 parent(T, e)求左孩子 LeftChild(T, e)求右孩子 RightChild(T, e)求左兄弟 LeftSibling(T, e)
C语言代码实现平衡二叉树|图解+详细代码
最新发布
2401_82584055的博客
05-04 436
平衡二叉树，我们也称【二叉平衡搜索树/AVL】,树中任何节点的两个子树的高度最大差别为1，巴拉巴拉。。。https://baike.baidu.com/item/AVL树/10986648?fr=aladdin但是有个注意的点: 平衡二叉树的前提是 二叉排序树(https://baike.baidu.com/item/二叉搜索树/7077855?fr=aladdin这篇博客主要总结平衡二叉树，所以，二叉排序树知识不会提及，但是会用到。
【数据结构】树（六）—— 二叉平衡树（C语言版）
haoweixl的博客
06-28 1793
【数据结构】树（六）—— 二叉平衡树（C语言版）前言 前言 在 《树（五）—— 二叉排序树》一文中，对二叉排序树进行性能分析时可知，当为二叉排序树时，其查找性能最佳，与二分查找类似。故需要对二叉排序树进行优化为二叉平衡树。 .........
09.二叉排序树和平衡二叉树
gudongkun1121的博客
01-21 1777
一、二叉排序树 1.什么是二叉排序树 二叉排序树要么是空二叉树 ，要么具有如下特点： 二叉排序树中，如果其根结点有左子树，那么左子树上所有结点的值都小于根结点的值； 二叉排序树中，如果其根结点有右子树，那么右子树上所有结点的值都大于根结点的值； 二叉排序树的左右子树也要求都是二叉排序树； 如下图就是一个二叉排序树： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VsGloKcV-1642763317481)(C:\Users\86186\AppData\Roaming\T
C语言数据结构之平衡二叉树（AVL树）实现方法示例
08-28
C语言数据结构之平衡二叉树（AVL树）实现方法示例 本文将详细介绍C语言数据结构之平衡二叉树（AVL树）实现方法，并结合实例形式分析了C语言平衡二叉树的相关定义与使用技巧。 知识点一：AVL树的定义 AVL树是一种...
C语言实现的AVL平衡二叉树
03-21
AVL平衡二叉树是一种自平衡的二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis在1962年提出，因此得名AVL树。这种数据结构的主要特点是其左右子树的高度差不超过1，从而确保了查找、插入和删除操作的平均时间...
C语言平衡二叉树.zip
10-27
总之，C语言实现平衡二叉树涉及的主要知识点包括：二叉树的基本概念、AVL树的特性、平衡因子的计算、旋转操作（左旋和右旋）以及如何在插入和删除操作后维护树的平衡。理解并掌握这些内容对于学习高级数据结构和算法...
二叉排序树和平衡二叉树
低吟不作语的博客
09-29 2116
概述 对于一组元素 [7, 3, 10, 12, 5, 1, 9] 可以有很多种存储方式，但无论使用哪种数据结构，都或多或少有缺陷。比如使用线性结构存储，排序方便，但查找效率低。二叉排序树的特点就是能在保证元素有序的同时，提高查找的效率。 二叉排序树的定义 二叉排序树，也叫二叉查找树，二叉搜索树，英文名 Binary Sort Tree（BST）。它或者是一颗空树，或者是一颗具有以下性质的二叉树 若左子树不为空，则左子树上所有结点的值均小于它的根结点的值 若右子树不为空，则右子树上所有结点...
二叉搜索树 c语言,二叉搜索树（C语言实现）
weixin_39823459的博客
05-23 314
数据结构typedef struct TreeNode {int data;//数据struct TreeNode* left;//左孩子struct TreeNode* right;//右孩子}BST, *BinTree;函数声明void Insert(BinTree& BST, int x);//插入元素void Delete(BinTree& BST, int x);//删除...
平衡二叉树的c语言实现
10-15
本代码用c语言实现了平衡二叉树这一数据结构，同时实现了基本查找，插入，删除操作，都是自己精心设计的算法，花了很多功夫。。
平衡二叉树 C语言代码实现
李肖遥的专栏
09-20 975
关注、星标公众号，直达精彩内容来源： https://www.cnblogs.com/NoneID整理：李肖遥1. 什么是平衡二叉树平衡二叉树，我们也称【二叉平衡搜索树/AVL】,树中任何节点的两个子树的高度最大差别为1，巴拉巴拉。。。(https://baike.baidu.com/item/AVL树/10986648?fr=aladdin)但是有个注意的点: 平衡二叉树的前提是 二叉排...
数据结构与算法(十六)——二叉排序树、平衡二叉树、多叉树
菜鸟的博客
05-01 429
二叉排序树(BST) 二叉排序树：BST(Binary Sort(Search) Tree)，对于BST中任何一个非叶子结点，要求左子节点的值比当前结点的值小，右子节点的值比当前结点的值大。对于相同的值，可以将该结点放在左子节点或者右子节点 代码实现 添加结点：根据结点的值，将值小的结点放在左边，值大的结点放在右边 遍历结点：与一般树的前中后序遍历无异 删除结点： 删除叶子结点：找到需要删除的结点的父结点，然后将叶子结点置空 删除只有一个子结点的结点：找到需要删除的结点的父结点，将父结点的子结点位置
平衡二叉树（AVL树）
小码农想做大架构的博客
06-03 505
概念:平衡二叉树(AVL树)是特殊的二叉排序树，特殊的地方在于左右子树高度之差绝对值不超过1，而且左右子树又是一颗平衡二叉树，左右子树的高度差为该结点的平衡因子，平衡因子的值只可能是-1、0、1。 平衡二叉树的建立过程和二叉排序树的建立过程是相似的，都是从一颗空树开始陆续插入结点。不同的地方在于平衡二叉树的建立过程中，由于插入结点可能破坏结点的平衡性。所以需要进行平衡调整。 以距离插入结点最近的，平衡因子绝对值大于1的结点为根称为最小不平衡子树。（即上图43、22、10） 每插入一个结点，都要检.
计算机考研408每日一题 day146
漫磋嗟
12-10 2028
若将关键字1，2，3，4，5，6，7依次插入到初始为空的平衡二叉树T中，则T中平衡因子为0的分支结点的个数是___。（武汉大学 2014年） 下面关于加密的说法中，错误的是___。（中山大学 2014年） 链接文件的正确概念___（电子科技大学 2013年） 指令系统中采用不同寻址方式的目的是___。（北京科技大学 2014年）
细讲平衡二叉树的C语言实现
qq_59978514的博客
08-10 346
平衡二叉树，又称为AVL 树。实际上就是遵循以下两个特点的二叉树： 每棵子树中的左子树和右子树的深度差不能超过 1； 二叉树中每棵子树都要求是平衡二叉树； 下面先看代码实现尔后再分析： #include <stdio.h> #include <stdlib.h> //分别定义平衡因子数 #define LH +1 #define EH 0 #define RH -1 typedef int ElemType; //定义二叉排序树 typedef struct BSTNo.
【数据结构】----平衡二叉树怎么自己画？
热门推荐
何新生(Daniel) 勇敢坚毅真正之才智乃刚毅之志向。 —— 拿破仑
01-08 3万+
【数据结构】平衡二叉树怎么自己画？        是什么？     要了解平衡二叉树，先得了解什么是二叉树？ 二叉树定义： 在计算机中，二叉树是每一个节点最多有两个子树的结构。通常子树被称作“左子树（left subtree）”“右子树（right subtree）”. 二叉树常被用于实现二叉树查找和二叉堆。 什么是平衡二叉树：      平衡二叉树（Balan
平衡二叉树的构造c语言,数据结构之---C语言实现平衡二叉树（AVL树）
06-02
下面是C语言实现平衡二叉树（AVL树）的代码： ``` #include #include /* 定义平衡二叉树节点结构体 */ struct AVLNode { int data; // 存储的数据 int height; // 节点高度 struct AVLNode *leftChild; // 左...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值