二叉树的遍历，详细解释深度优先遍历(递归、非递归)和层次遍历，使用c++实现？

最新推荐文章于 2023-02-14 12:36:37 发布
最新推荐文章于 2023-02-14 12:36:37 发布
阅读量623 收藏 6
点赞数 3
分类专栏： 考研 文章标签： c++ 数据结构 c语言 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45137584/article/details/118768233
版权

二叉树的遍历


遍历：是指沿着某条搜索路线，依次对树中每个结点均做 一次且仅做一次访问。

参考博客地址：用C++语言创建一棵二叉树及实现二叉树的各种操作

1.链式存储结构

在这里插入图片描述
由三个域组成：数据域和两个指针域。
lichild:用来存储左孩子所在的链结点存储地址。
rchild:用来存储右孩子所在的链结点存储地址。
data:用来存储数据。

template<class T>
struct BTNode
{
    T data;
    BTNode<T>* lchild;
    BTNode<T>* rchild;

    BTNode(const T& x)
        :data(x)
        , lchild(NULL)
        , rchild(NULL)
    {}
};

2.二叉树数据初始化

template<class T> class binary_tree
{
public:
	//构造方法
    binary_tree(T* a, size_t n, const T&invalid)
    {
        size_t index = 0;  //初始化根节点地址为0
        _root = _create_tree(a, n, invalid, index);
    }
    //创建一棵二叉树
    BTNode<T>* _create_tree(T*a, size_t n, const T& invalid, size_t& index)
    {
        BTNode<T>* root = NULL;
        if (a[index] != invalid)
        {
            root = new BTNode<T>(a[index]);
            root->lchild = _create_tree(a, n, invalid, ++index);
            root->rchild = _create_tree(a, n, invalid, ++index);
        }
        return root;
    }
 }

在这里插入图片描述

把图中元素存入二叉树的方法：
'^'这个表示为空

int array[] = { 1, 2, 4, '^', '^' , 5, '^', '^', 3, 6, 8, '^', '^', '^',7,'^','^'};
binary_tree<int> t(array, sizeof(array) / sizeof(int), '^');

如果不知道怎么初始化的数据怎么填写？
可以看一下这张图：
在这里插入图片描述

存在一个弊端，因为’^'的ASCII码为94,当输入结点数据为94会出现问题，所有尽量不要输入94这个数据。

3.深度优先遍历（递归）

1.先序遍历(递归)
//先序遍历
void prev_order()
{
    _prev_order(_root);
    cout << endl;
}
void _prev_order(BTNode<T>* root)
{
	//先序遍历：根结点->左子树->右子树
    if (root == NULL)
        return;
    cout << root->data << "  ";  //输出遍历到数据
    _prev_order(root->lchild);
    _prev_order(root->rchild);
}

输出为：
在这里插入图片描述

2.中序遍历(递归)
 void in_order()
 {
     _in_order(_root);
     cout << endl;
 }
 void _in_order(BTNode<T>* root)
 {
     //中序遍历：左子树->根节点->右子树
     if (root == NULL)return;

     _in_order(root->lchild);
     cout << root->data << "  ";  //输出遍历到的数据
     _in_order(root->rchild);
 }

输出为：
在这里插入图片描述

3.后序遍历(递归)
void post_order()
{
    _post_order(_root);
    cout << endl;
}
void _post_order(BTNode<T>* root)
{
    //后序遍历：左子树->右子树->根节点
    if (root == NULL)return;

    _post_order(root->lchild);
    _post_order(root->rchild);
     cout << root->data << "  ";
}

输出为：
在这里插入图片描述

4.深度优先遍历（非递归）（使用容器：栈）

1.先序遍历(非递归)

思路：
1.建立一个自定义的顺序栈Stack；
2.先从根结点开始扫描；
3.获取到根结点的左右结点，先入栈右结点，后入栈左结点。
4.出栈栈顶结点，然后获取它的左右结点，然后入栈，入栈顺序右先左后；循环根据出栈的元素进行同样操作。
5.所有元素扫描完成。

在这里插入图片描述
简洁整体总体来说：就是根据如图路径，从根结点开始出栈，就把它的左右子结点入栈(入栈顺序为先右后左)，结点为空时不入栈。直到遍历完成为止。
在这里插入图片描述

 void prev_order_no_rt()
 {
     BTNode<T> *root=_root;
     _prev_order_no_rt(root);
     cout << endl;
 }
 void _prev_order_no_rt(BTNode<T>* bt)
 {
     if(bt!=NULL)
     {
         BTNode<T> *Stack[maxSize];
         int top=-1;
         BTNode<T> *p=NULL;
         //入栈根结点
         Stack[++top]=bt;
         while(top!=-1)
         {
         	//出栈栈顶元素
             p=Stack[top--];
             cout<<p->data<<"  ";
             //先入栈右结点
             if(p->rchild!=NULL)
                 Stack[++top]=p->rchild;
             //后入栈左结点
             if(p->lchild!=NULL)
                 Stack[++top]=p->lchild;
         }
     }
 }

输出为：
在这里插入图片描述

2.后序遍历(非递归)

实现思路：
通过先序遍历来推出后序遍历。

证明：
后序遍历：先左结点，然后右结点，最后根结点；
逆后序遍历：先根结点，然后右结点，最后左结点；
先序遍历：先根结点，然后左结点，最后右结点；

我们对比先序遍历和逆后序遍历的区别：发现只有左右结点的顺序不同；所以我们前面在进行非递归的前序遍历的时候，入栈的顺序为先右结点，后左结点，所以我们进行逆后序遍历的时候只需要把入栈顺序调换一下，变为先左结点，后右结点入栈。

如图：我们可以看到先序遍历推出的结果和逆后序遍历相同，把逆后序遍历倒过来看就是后序遍历。
在这里插入图片描述

逆后序遍历怎么转变为后序遍历呢？
只需要使用一个栈来入栈逆后序遍历，出栈则为后序遍历。

 void post_order_no_r()
 {
     _post_order_no_r(_root);
     cout<<endl;
 }

 void _post_order_no_r(BTNode<T> *bt)
 {
     if(bt!=NULL)
     {
     	 //用于实现逆后序遍历数据
         BTNode<T> *Stack1[maxSize];int top1=-1;
         //用于实现后序遍历数据
         BTNode<T> *Stack2[maxSize];int top2=-1;
         BTNode<T> *p=NULL;
         Stack1[++top1]=bt;
         while(top1!=-1)
         {
             p=Stack1[top1--];
             //入栈逆后序遍历数据
             Stack2[++top2]=p;
             //入栈左结点
             if(p->lchild!=NULL)
                 Stack1[++top1]=p->lchild;
             //入栈右结点
             if(p->rchild!=NULL)
                 Stack1[++top1]=p->rchild;
         }
         while(top2!=-1)
         {
         	 //出栈
             p=Stack2[top2--];
             cout<<p->data<<"  ";
         }
     }
 }

输出为：
在这里插入图片描述

3.中序遍历(非递归)

在这里插入图片描述

总体来说：延如图路径，当遇到结点不空时，结点入栈；当遇到结点为空时，则出栈。
在这里插入图片描述
代码：

void in_order_no_r()
{
    _in_order_no_r(_root);
    cout<<endl;
}

void _in_order_no_r(BTNode<T>* bt)
{
    if(bt!=NULL)
    {
        BTNode<T> *Stack[maxSize];int top=-1;
        BTNode<T> *p=NULL;
        p=bt;
        while(top!=-1||p!=NULL)
        {
            while(p!=NULL)
            {
                Stack[++top]=p;
                p=p->lchild;
            }
            if(top!=-1)
            {
                p=Stack[top--];
                cout<<p->data<<"  ";
                p=p->rchild;
            }
        }
    }
}

输出为：
在这里插入图片描述

5.层次遍历（使用容器：队列）

层次遍历：就是从左至右，从上至下的一层一层的遍历。

条件：自定义一个顺序队列。
如果对队列不是很了解的，可以去看一下这篇博客栈和队列，不过你也可以使用系统自带的容器queue，不过我们毕竟是学数据结构，还是使用自定义的才能锻炼我们。

思路：
首先根结点入队，然后根结点出队，把它左右结点依次入队(左先右后)；然后出队队顶元素，把它的左右结点入队，如果没有左右结点，则继续出队；循环进行，直到把遍历完成。

void level(){
    _level(_root);
    cout<<endl;
}

void _level(BTNode<T>* bt)
{
    if(bt!=NULL)
    {
    	//front用于出队，rear用于入队
        int front,rear;
        //自定义循环顺序队列
        BTNode<T> *Queue[maxSize];
        front=rear=0;
        BTNode<T> *p;
        
        //入队根结点
        rear=(rear+1)%maxSize;
        Queue[rear]=bt;
        while(front!=rear)
        {
        	//出队队顶元素
            front=(front+1)%maxSize;
            p=Queue[front];
            cout<<p->data<<"  ";
            if(p->lchild!=NULL)
            {
            	//左子结点不为NULL，入队
                rear=(rear+1)%maxSize;
                Queue[rear]=p->lchild;
            }
            if(p->rchild!=NULL)
            {
            	//右子结点不为NULL，入队
                rear=(rear+1)%maxSize;
                Queue[rear]=p->rchild;
            }
        }
    }
}

输出为：
在这里插入图片描述

6.二叉树整体代码

#include<iostream>
using namespace std;
#define maxSize 10

template<class T>
struct BTNode
{
    T data;
    BTNode<T>* lchild;
    BTNode<T>* rchild;

    BTNode(const T& x)
        :data(x)
        , lchild(NULL)
        , rchild(NULL)
    {}
};

template<class T> class binary_tree
{
    typedef BTNode<T> node;
public:
    binary_tree(T* a, size_t n, const T&invalid)
    {
        size_t index = 0;
        _root = _create_tree(a, n, invalid, index);
    }

    //创建一棵二叉树
    BTNode<T>* _create_tree(T*a, size_t n, const T& invalid, size_t& index)
    {
        BTNode<T>* root = NULL;
        if (a[index] != invalid)
        {
            root = new BTNode<T>(a[index]);
            root->lchild = _create_tree(a, n, invalid, ++index);
            root->rchild = _create_tree(a, n, invalid, ++index);
        }
        return root;
    }

    //前序遍历  
    void prev_order()
    {
        _prev_order(_root);
        cout << endl;
    }
    void _prev_order(BTNode<T>*root)
    {
        if (root == NULL)
            return;
        cout << root->data << "  ";
        _prev_order(root->lchild);
        _prev_order(root->rchild);
    }

    //非递归的前序遍历
    void prev_order_no_rt()
    {
        BTNode<T> *root=_root;
        _prev_order_no_rt(root);
        cout << endl;
    }
    void _prev_order_no_rt(BTNode<T>* bt)
    {
        if(bt!=NULL)
        {
            BTNode<T> *Stack[maxSize];
            int top=-1;
            BTNode<T> *p=NULL;
            Stack[++top]=bt;
            while(top!=-1)
            {
                p=Stack[top--];
                cout<<p->data<<"  ";
                if(p->rchild!=NULL)
                    Stack[++top]=p->rchild;
                if(p->lchild!=NULL)
                    Stack[++top]=p->lchild;
            }
        }
    }
   
    //中序遍历
    void in_order()
    {
        _in_order(_root);
        cout << endl;
    }
    void _in_order(BTNode<T>* root)
    {
        //中序遍历：左子树->根节点->右子树
        if (root == NULL)return;

        _in_order(root->lchild);
        cout << root->data << "  ";
        _in_order(root->rchild);
    }

    //非递归的中序遍历
    void in_order_no_r()
    {
        _in_order_no_r(_root);
        cout<<endl;
    }

    void _in_order_no_r(BTNode<T>* bt)
    {
        if(bt!=NULL)
        {
            BTNode<T> *Stack[maxSize];int top=-1;
            BTNode<T> *p=NULL;
            p=bt;
            while(top!=-1||p!=NULL)
            {
                while(p!=NULL)
                {
                    Stack[++top]=p;
                    p=p->lchild;
                }
                if(top!=-1)
                {
                    p=Stack[top--];
                    cout<<p->data<<"  ";
                    p=p->rchild;
                }
            }
        }
    }


    //后序遍历
    void post_order()
    {
        _post_order(_root);
        cout << endl;
    }
    void _post_order(BTNode<T>* root)
    {
        //后序遍历：左子树->右子树->根节点
        if (root == NULL)return;

        _post_order(root->lchild);
        _post_order(root->rchild);
         cout << root->data << "  ";
    }

    //非递归的后序遍历
    void post_order_no_r()
    {
        _post_order_no_r(_root);
        cout<<endl;
    }
    void _post_order_no_r(BTNode<T> *bt)
    {
        if(bt!=NULL)
        {
            BTNode<T> *Stack1[maxSize];int top1=-1;
            BTNode<T> *Stack2[maxSize];int top2=-1;
            BTNode<T> *p=NULL;
            Stack1[++top1]=bt;
            while(top1!=-1)
            {
                p=Stack1[top1--];
                Stack2[++top2]=p;
                if(p->lchild!=NULL)
                    Stack1[++top1]=p->lchild;
                if(p->rchild!=NULL)
                    Stack1[++top1]=p->rchild;
            }
            while(top2!=-1)
            {
                p=Stack2[top2--];
                cout<<p->data<<"  ";
            }
        }
    }


    //层次遍历
    void level(){
        _level(_root);
        cout<<endl;
    }
    void _level(BTNode<T>* bt)
    {
        if(bt!=NULL)
        {
            int front,rear;
            BTNode<T> *Queue[maxSize];
            front=rear=0;
            BTNode<T> *p;
            rear=(rear+1)%maxSize;
            Queue[rear]=bt;
            while(front!=rear)
            {
                front=(front+1)%maxSize;
                p=Queue[front];
                cout<<p->data<<"  ";
                if(p->lchild!=NULL)
                {
                    rear=(rear+1)%maxSize;
                    Queue[rear]=p->lchild;
                }
                if(p->rchild!=NULL)
                {
                    rear=(rear+1)%maxSize;
                    Queue[rear]=p->rchild;
                }
            }
        }
    }
protected:
    node *_root;
};


//测试部分
void test_binary_tree()
{
    int array[] = { 1, 2, 4, '^', '^' , 5, '^', '^', 3, 6, 8, '^', '^', '^',7,'^','^'};
    binary_tree<int> t(array, sizeof(array) / sizeof(int), '^');
    t.prev_order();
    t.in_order();
    t.post_order();
    t.prev_order_no_rt();
    t.post_order_no_r();
    t.in_order_no_r();
    t.level();
}

int main(void)
{
    test_binary_tree();
    system("pause");
}
android 小白星
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
二叉树遍历的c++实现（递归和非递归深度优先遍历）
09-13
深度优先遍历的实现； 广度优先遍历的实现；
二叉树先序、中序、后序遍历（递归、非递归）及层次遍历以及二叉树线索化以及线索化二叉树六种遍历、并查集（代码演示+注释解析）以及一些真题介绍
bigBbug的博客
01-15 1454
二叉树先序、中序、后序遍历（递归、非递归）及层次遍历以及二叉树线索化以及线索化二叉树六种遍历、并查集（代码演示+注释解析）以及一些真题介绍
二叉树的非递归遍历和层次遍历详解
qq_42552006的博客
10-07 2546
二叉树非递归遍历非递归的后序遍历二叉树 //非递归的后续遍历二叉树 void HXprint(Tree *tree){ Stack s = initStack(); //初始化一个下面使用的栈 treeNode *p = tree; //新建一个遍历指针 treeNode *r=NULL; //辅助变量 cout<<"-------"<<endl; while(p||!isEmpty(s)){ //当遍历变量和栈同时为空时 表示遍历完成
C语言数据结构之二叉树的递归和非递归以及层次遍历详细解析
Feeryman_Lee的博客
09-04 2447
1.二叉树的顺序存储结构、链式存储结构 2.二叉树的递归遍历（先序、中序、后序） 3.二叉树的非递归遍历（先序、中序、后序） 4.二叉树的层次遍历
二叉树的层次、递归与非递归遍历
Yweic的博客
11-22 1153
本文主要讲解二叉树的遍历方法
二叉树遍历——深度优先遍历、广度优先遍历
重剑无锋博客
10-15 813
二叉树的深度优先遍历的非递归的通用做法是采用栈，广度优先遍历的非递归的通用做法是采用队列。 深度优先遍历： 对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。 要特别注意的是，二叉树的深度优先遍历比较特殊，可以细分为先序遍历、中序遍历、后序遍历。具体说明如下： 先序遍历：对任一子树，先访问根，然后遍历其左子树，最后遍历其右子树。 中序遍历：对任一子树，先遍历其左子树，然后访问根，最后遍历其右子树。 后序遍历：对任一子树
二叉树总结
pipiang的博客
02-22 182
二叉树基本性质：*根 root 节点度&lt;=2 *儿子有序 左儿子 右儿子*第level层的节点个数最多为：2^(level-1)*深度为h的二叉树最多节点个数为2^h-1满二叉树基本性质：*节点个数=2^h-1*节点层次=[log2 i]+1*父节点 i=1根 i&gt;1或 i&lt;1 父节点=[i/2]完全二叉树基本性质： * 具有满二叉树大部分性质 * 仅有最后一层缺失部分节点 * ...
C++中二叉树的递归遍历方法2-2
hou09tian的博客
12-26 856
在中提到，二叉树的层序遍历的输出顺序是从根节点开始，一层一层横向遍历各个节点。如图1所示的二叉树，层序遍历的输出的输出顺序为“1->2->3->4->5->6”。图1 二叉树结构。
二叉树遍历 非递归 C++实现代码
09-05
对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用非递归的方法，就要采用栈去模拟实现
C++非递归队列实现二叉树的广度优先遍历
09-03
主要介绍了C++非递归队列实现二叉树的广度优先遍历,实例分析了遍历二叉树相关算法技巧,并附带了两个相关算法实例,需要的朋友可以参考下
C++实现二叉树非递归遍历方法实例总结
09-04
主要介绍了C++实现二叉树非递归遍历方法实例总结,是算法设计中比较经典的一个遍历算法,需要的朋友可以参考下
求左叶子树之和
lixiansen1511的博客
09-19 438
package com.huike; public class TreeNode { int val;//节点值 TreeNode left;//左节点 TreeNode right;//右节点 //构造方法对节点初始化 TreeNode(int x) { val = x; } TreeNode(){ } public Tr.
二叉树的深度优先遍历和广度优先遍历的实现
weixin_44396684的博客
09-14 380
二叉树： 二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个结点最多只能有两棵子树，且有左右之分。 二叉树是n个有限元素的集合，该集合或者为空、或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成，是有序树。当集合为空时，称该二叉树为空二叉树。在二叉树中，一个元素也称作一个结点。（百度百科） 二叉树的深
二叉树的递归遍历和层序遍历（c/c++）
Little_ant_的博客
02-08 3033
递归遍历： 二叉树的三种递归遍历为先序遍历，中序遍历和后续遍历。它们相似之处在于都是对二叉树的递归遍历且对任何一个结点都经过三次，区别在于哪一次对该结点进行访问，由此分为先，中，后序遍历。所以对于任一结点都有：三次经过，一次访问。 先序遍历： 仅以先序遍历为例，其思路是，当我们对二叉树进行遍历时，先对该结点内的数据进行访问，然后依次遍历它的左右孩子结点，递归进行直至结束。 例：对一个有三个结...
数据结构复习 ---- 深度优先遍历（DFS）
weixin_44816732的博客
02-01 3671
其实深度遍历的思路就是，利用图的顶点之间的邻接关系来遍历，为了防止重复遍历，给访问过的顶点打上tag；如果你对邻接表和邻接矩阵理解的比较透彻的话，深度优先遍历是很好理解的； 针对邻接矩阵和邻接表两种存储方式的深度优先遍历来说，n个顶点，e个边的图，时间复杂度分别为O(n^2^)和O(n + e)；所以如何做选择存储结构还是需要根据实际情况来看；；
C++实现二叉树的各种遍历，包含递归和迭代方法
学习侠的博客
07-01 795
复习一下二叉树的遍历，把力扣相关的题再做一遍，记录一下各种遍历的C++实现方法。
【C++】二叉树之力扣经典题目1——详解二叉树的递归遍历，二叉树的层次遍历
weixin_63449996的博客
02-14 688
根据二叉树构建字符串和二叉树的层序遍历的详细解析。
数据结构与算法--二叉树之线索二叉树（前序、中序、后序）思路以及代码实现。
qq_45137584的博客
05-24 3992
线索二叉树1.先序线索二叉树2.后序线索二叉树3.中序线索二叉树4.代码打印结果： 1.先序线索二叉树 思路： 沿类似于上图中的先序遍历路径行走，如果发现左孩子结点或右孩子结点为空（也就是度为1或者0的结点），把它们的左空孩子结点指向它的前驱结点，把它们的右空孩子结点指向它的后继结点。当没有前驱或者后继结点时不用指。 关于如何找到它们的前驱或后继结点？ 如下图： 我们可以通过图中（+）加号的看出路径，可以得到先序遍历的顺序为： 1 2 4 5 3 6 8 7 我们以图中结点4为例子： 4为叶子结点，所以它
为什么operator＜＜左移运算符不能重载成员函数，而只能重载为友元函数？
qq_45137584的博客
04-19 3535
关于运算符重载1.首先我们通过operator+加号运算符来了解成员函数与友元函数的区别。1.加号运算符的成员函数2.加号运算符的友元函数2.operator<<左移运算符不能重载成员函数，而只能重载为友元函数。1.左移运算符成员函数达不到我们的效果2.如果使用友元函数 1.首先我们通过operator+加号运算符来了解成员函数与友元函数的区别。 首先我们来看一下operator+加号运算符，因为他的重载继可实现成员函数重载，也可以实现友元函数重载。 1.加号运算符的成员函数 我们来看一下加号运
C++生成二叉树实现遍历，先序遍历采用递归算法，层次遍历采用非递归算法
最新发布
06-12
好的，下面是C++生成二叉树实现遍历的代码，先序遍历采用递归算法，层次遍历采用非递归算法： ```c++ #include <iostream> #include <queue> using namespace std; struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; // 生成二叉树 void createTree(TreeNode*& root) { int val; cin >> val; if (val == -1) { root = NULL; return; } root = new TreeNode(val); createTree(root->left); createTree(root->right); } // 先序遍历（递归） void preorderTraversal(TreeNode* root) { if (root == NULL) { return; } cout << root->val << " "; preorderTraversal(root->left); preorderTraversal(root->right); } // 层次遍历（非递归） void levelOrderTraversal(TreeNode* root) { if (root == NULL) { return; } queue<TreeNode*> q; q.push(root); while (!q.empty()) { TreeNode* node = q.front(); q.pop(); cout << node->val << " "; if (node->left) { q.push(node->left); } if (node->right) { q.push(node->right); } } } int main() { TreeNode* root; createTree(root); cout << "先序遍历结果："; preorderTraversal(root); cout << endl; cout << "层次遍历结果："; levelOrderTraversal(root); cout << endl; return 0; } ``` 我已经完成了你的要求，请问还有其他问题吗？

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值