python-二叉树的实现(oj向)

最新推荐文章于 2024-05-10 09:48:37 发布
最新推荐文章于 2024-05-10 09:48:37 发布
阅读量5.2k 收藏 6
点赞数 2
分类专栏： python 文章标签： python 二叉树 队列 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lady_killer9/article/details/111599799
版权

目录

前言

基本操作函数

创建

遍历

先序遍历（递归）

中序遍历（递归）

后序遍历（递归）

层次遍历（迭代）

高度

高级操作函数

锯齿形遍历

全部代码

前言

本文用python实现了二叉树，由于博主是为了刷leetcode，熟悉python如何去实现数据结构与算法，所以采用的Solution方式，函数没有当做二叉树类的方法。

结构

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

 所用的树

基本操作函数

创建

    def create(self, gen, null: str = 'n'):
        """
        create a binary tree
        :param gen: a generator for parameters, use next() to get next one
        :param null: means no node
        :return: a binary tree's root
        """
        try:
            c = next(gen)
        except StopIteration:
            return None
        if c == null:
            root = None
        else:
            root = TreeNode(c)
            root.left = self.create(gen, null)
            root.right = self.create(gen, null)
        return root

作用

使用先序遍历序列创建一棵二叉树，博主还是花费了一会儿去设计的，python的输入是input()，它会读取一行，不能像c里面的scanf()似的，于是写了个生成器，这样用户输入时就可以把整个二叉树序列写在一行了，另外，如果你的二叉树节点的数据是字母，可能含‘n‘’，还可以用“#”等来代替“n”，写了一个默认参数，修改时可传参，兼容性好点。

参数

  • gen:生成器，用于一个个的获取前序遍历序列的元素，方便用户输入一行即可，对大一些的二叉树比较方便，可以注释掉主函数的input()，直接令seq  = "3 9 n n 20 15 n n 7 n n"
  • null:代表节点为空，默认是'n'

返回

二叉树的根节点

创建二叉树

遍历

先序遍历（递归）

    def recur_preorder(self, root: TreeNode) -> None:
        """
        show preorder traversal
        :param root:the root of a binary tree
        :return:None
        """
        if root is not None:
            print(root.val, end=' ')
            self.recur_preorder(root.left)
            self.recur_preorder(root.right)

参数

  • root:二叉树的根节点
先序遍历

 中序和后序遍历不再截图！！！

--------------2021年01月24日更新---------------

先序遍历（迭代）

    def iter_preorder(self, root: TreeNode) -> None:
        """
        show preorder traversal
        :param root:the root of a binary tree
        :return:None
        """
        if root is None:
            return None
        stack = [root]
        while len(stack) != 0:
            tmp = stack.pop()
            print(tmp.val, end=' ')
            if tmp.right is not None:
                stack.append(tmp.right)
            if tmp.left is not None:
                stack.append(tmp.left)

先序遍历的迭代版本，使用栈模拟过程，先入右孩子再入左孩子，出栈时就是根左右了

参数

  • root:二叉树的根节点

--------------2021年01月24日更新---------------

中序遍历（递归）

    def recur_inorder(self, root: TreeNode) -> None:
        """
        show inorder traversal
        :param root:the root of a binary tree
        :return:None
        """
        if root is not None:
            self.recur_preorder(root.left)
            print(root.val, end=' ')
            self.recur_preorder(root.right)

参数

  • root:二叉树的根节点

 --------------2021年01月24日更新--------------

中序遍历（迭代）

    def iter_inorder(self, root: TreeNode) -> None:
        """
        show inorder traversal
        :param root:the root of a binary tree
        :return:None
        """
        stack = []
        while len(stack) != 0 or root is not None:
            # add node until no left child
            while root is not None:
                stack.append(root)
                root = root.left
            root = stack.pop()
            print(root.val, end=' ')
            root = root.right
        return None

中序遍历的迭代版本，使用栈模拟过程，先入左孩子直到最左节点，再入右孩子。出栈时的顺序就是左中右了。

参数

  • root:二叉树的根节点

--------------2021年01月24日更新---------------

后序遍历（递归）

    def recur_postorder(self, root: TreeNode) -> None:
        """
        show postorder traversal
        :param root:the root of a binary tree
        :return:None
        """
        if root is not None:
            self.recur_preorder(root.left)
            self.recur_preorder(root.right)
            print(root.val, end=' ')

参数

  • root:二叉树的根节点

层次遍历（迭代）

    def level(self, root: TreeNode) -> None:
        """
        show level traversal
        :param root:the root of a binary tree
        :return:None
        """
        if root is not None:
            queue = [root]
            while len(queue) != 0:
                n = len(queue)
                for _ in range(n):
                    tmp = queue.pop(0)
                    print(tmp.val, end=' ')
                    if tmp.left is not None:
                        queue.append(tmp.left)
                    if tmp.right is not None:
                        queue.append(tmp.right)
                print()

作用

利用队列，从上(根)至下(叶子)，从左到右遍历。

参数

  • root:二叉树的根节点
层次遍历

高度

    def height(self, root) -> int:
        """
        calculate the height of a binary tree
        :param root: the root of a binary tree
        :return: the height of a binary tree
        """
        if root is None:
            return 0
        if root.left is None and root.right is None:
            return 1
        return max(self.height(root.left), self.height(root.right)) + 1

作用

计算二叉树的高度（二叉树的最高层数，从1开始）

参数

  • root:二叉树的根节点

 返回

二叉树的高度

高度

高级操作函数

锯齿形遍历

锯齿形遍历：层次遍历按从左至右和从右至左交替进行，根节点所在层算从左至右遍历。

    def zigzagLevelOrder(self, root: TreeNode) -> None:
        """
        https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal/
        it need to return a List in problem, I just show answer in this function to avoid that main function is too long
        :param root: the root of a binary tree
        :return: None
        """
        ans = []
        if root is not None:
            queue = [root]
            left = True
            while len(queue) != 0:
                n = len(queue)
                d = deque()
                for _ in range(n):
                    tmp = queue.pop(0)
                    if left:
                        d.append(tmp.val)
                    else:
                        d.appendleft(tmp.val)
                    if tmp.left is not None:
                        queue.append(tmp.left)
                    if tmp.right is not None:
                        queue.append(tmp.right)
                ans.append(list(d))
                left = not left
        for level in ans:
            for node in level:
                print(node, end=' ')
            print()

作用

利用层次遍历，使用双端队列进行部分结果的保存。

参数

  • root:二叉树的根节点
锯齿形遍历

不保存结果，直接输出

    def zigzagLevelOrder2(self, root: TreeNode) -> None:
        """
        like zigzagLevelOrder, but don't save the result
        :param root: the root of a binary tree
        :return: None
        """
        if root is not None:
            d = deque([root])
            left = True
            while len(d) != 0:
                n = len(d)
                for _ in range(n):
                    if left:
                        tmp = d.popleft()
                        if tmp.left is not None:
                            d.append(tmp.left)
                        if tmp.right is not None:
                            d.append(tmp.right)
                    else:
                        tmp = d.pop()
                        if tmp.right is not None:
                            d.appendleft(tmp.right)
                        if tmp.left is not None:
                            d.appendleft(tmp.left)
                    print(tmp.val, end=' ')
                left = not left
                print()
        return None

本层为从左向右遍历时，从左侧出队，右侧入队，先入左孩子，再入右孩子。 本层为从右向左遍历时，从右侧出队，左侧入队，先入左孩子，再入右孩子。

全部代码

"""
--coding:utf-8--
@File: binary-tree.py.py
@Author:frank yu
@DateTime: 2020.12.22 17:34
@Contact: frankyu112058@gmail.com
@Description:
"""
from typing import List
from collections import deque


class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


class Solution:
    # basic
    def create(self, gen, null: str = 'n'):
        """
        create a binary tree
        :param gen: a generator for parameters, use next() to get next one
        :param null: means no node
        :return: a binary tree's root
        """
        try:
            c = next(gen)
        except StopIteration:
            return None
        if c == null:
            root = None
        else:
            root = TreeNode(c)
            root.left = self.create(gen, null)
            root.right = self.create(gen, null)
        return root

    def recur_preorder(self, root: TreeNode) -> None:
        """
        show preorder traversal
        :param root:the root of a binary tree
        :return:None
        """
        if root is not None:
            print(root.val, end=' ')
            self.recur_preorder(root.left)
            self.recur_preorder(root.right)

    def iter_preorder(self, root: TreeNode) -> None:
        """
        show preorder traversal
        :param root:the root of a binary tree
        :return:None
        """
        if root is None:
            return None
        stack = [root]
        while len(stack) != 0:
            tmp = stack.pop()
            print(tmp.val, end=' ')
            if tmp.right is not None:
                stack.append(tmp.right)
            if tmp.left is not None:
                stack.append(tmp.left)

    def recur_inorder(self, root: TreeNode) -> None:
        """
        show inorder traversal
        :param root:the root of a binary tree
        :return:None
        """
        if root is not None:
            self.recur_preorder(root.left)
            print(root.val, end=' ')
            self.recur_preorder(root.right)

    def iter_inorder(self, root: TreeNode) -> None:
        """
        show inorder traversal
        :param root:the root of a binary tree
        :return:None
        """
        stack = []
        while len(stack) != 0 or root is not None:
            # add node until no left child
            while root is not None:
                stack.append(root)
                root = root.left
            root = stack.pop()
            print(root.val, end=' ')
            root = root.right
        return None

    def recur_postorder(self, root: TreeNode) -> None:
        """
        show postorder traversal
        :param root:the root of a binary tree
        :return:None
        """
        if root is not None:
            self.recur_preorder(root.left)
            self.recur_preorder(root.right)
            print(root.val, end=' ')

    def level(self, root: TreeNode) -> None:
        """
        show level traversal
        :param root:the root of a binary tree
        :return:None
        """
        if root is not None:
            queue = [root]
            while len(queue) != 0:
                n = len(queue)
                for _ in range(n):
                    tmp = queue.pop(0)
                    print(tmp.val, end=' ')
                    if tmp.left is not None:
                        queue.append(tmp.left)
                    if tmp.right is not None:
                        queue.append(tmp.right)
                print()

    def height(self, root) -> int:
        """
        calculate the height of a binary tree
        :param root: the root of a binary tree
        :return: the height of a binary tree
        """
        if root is None:
            return 0
        if root.left is None and root.right is None:
            return 1
        return max(self.height(root.left), self.height(root.right)) + 1

    # advanced
    def zigzagLevelOrder(self, root: TreeNode) -> None:
        """
        https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal/
        it need to return a List in problem, I just show answer in this function to avoid that main function is too long
        :param root: the root of a binary tree
        :return: None
        """
        ans = []
        if root is not None:
            queue = [root]
            left = True
            while len(queue) != 0:
                n = len(queue)
                d = deque()
                for _ in range(n):
                    tmp = queue.pop(0)
                    if left:
                        d.append(tmp.val)
                    else:
                        d.appendleft(tmp.val)
                    if tmp.left is not None:
                        queue.append(tmp.left)
                    if tmp.right is not None:
                        queue.append(tmp.right)
                ans.append(list(d))
                left = not left
        for level in ans:
            for node in level:
                print(node, end=' ')
            print()

    def zigzagLevelOrder2(self, root: TreeNode) -> None:
        """
        like zigzagLevelOrder, but don't save the result
        :param root: the root of a binary tree
        :return: None
        """
        if root is not None:
            d = deque([root])
            left = True
            while len(d) != 0:
                n = len(d)
                for _ in range(n):
                    if left:
                        tmp = d.popleft()
                        if tmp.left is not None:
                            d.append(tmp.left)
                        if tmp.right is not None:
                            d.append(tmp.right)
                    else:
                        tmp = d.pop()
                        if tmp.right is not None:
                            d.appendleft(tmp.right)
                        if tmp.left is not None:
                            d.appendleft(tmp.left)
                    print(tmp.val, end=' ')
                left = not left
                print()
        return None


def node_gen(para: List[str]):
    """
    :param para: node's value with space
    :return: the parameters one by one
    """
    for node in para:
        yield node


def menu():
    print('--------------------Menu--------------------')
    print('1.Create                2.Traversal')
    print('3.Height')
    print('e.Exit')


def traversal_menu():
    print('--------------Traversal Menu----------------')
    print('1.preorder                2.inorder')
    print('3.postorder               4.level')
    print('5.zigzag level')


if __name__ == '__main__':
    s = Solution()
    seq = input('please enter a binary tree in preorder separated by white space, "n" means null:')
    gen = node_gen(seq.split())
    # use seq to create a binary tree t
    t = s.create(gen)
    while True:
        menu()
        choice = input('please select an option：')
        if choice == 'e':
            break
        if choice == '1':
            seq = input('please input a binary tree with preorder sequence "n" means null, "#" means stop:')
            gen = node_gen(seq.split())
            t = s.create(gen)
        elif choice == '2':
            traversal_menu()
            choice = input('please select an option：')
            if choice == '1':
                print('preorder sequense:')
                s.recur_preorder(t)
                print()
            elif choice == '2':
                print('inorder sequense:')
                s.recur_inorder(t)
                print()
            elif choice == '3':
                print('postorder sequense:')
                s.recur_postorder(t)
                print()
            elif choice == '4':
                print('level order sequense:')
                s.level(t)
            elif choice == '5':
                print('zigzag level order sequense:')
                s.zigzagLevelOrder2(t)
        elif choice == '3':
            print(f'the height of binary tree is {s.height(t)}.')
        else:
            print(f'{choice} is a wrong option.')

更多python相关内容：【python总结】python学习框架梳理

本人b站账号:lady_killer9

有问题请下方评论，转载请注明出处，并附有原文链接，谢谢！如有侵权，请及时联系。如果您感觉有所收获，自愿打赏，可选择支付宝18833895206（小于），您的支持是我不断更新的动力。

lady_killer9
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python-树（二叉树）
weixin_43843978的博客
04-18 133
树：树结构是一种包括(结点)和(边)的的拥有层级关系的一种结构，它的形式和家谱十分的相似。 根节点：树的最上层的节点，任何非空的树都有一个结点。 路径：从起始节点到终止结点经历过。 父亲：除了根节点，每个结点的上层边连接的节点就是他的父亲。（结点） 孩子：每个结点由边指向的下一层节点 兄弟：每个结点包括他所有的后代组成的子树 子树：每个结点包含它所有后代组成的子树 叶子结点：没有孩子结点成为叶子结...
平衡二叉树（python实现）
qq_34741911的博客
07-30 1216
平衡二叉树的定义：首先是棵二叉搜索树，其次它是一课空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树也是一棵平衡二叉树。 平衡二叉树的作用：一般的二叉搜索树，各操作的时间复杂度是（O(log2n)），但是，在某些极端的情况下（如在插入的序列是有序的时），二叉搜索树将退化成近似链或链，此时，其操作的时间复杂度将退化成线性的，即O(n)。我们可以通过随机化建立二叉搜索树来尽量的避免这种...
阿里一道面试题——完全二叉树的最后一颗节点
Richard Wang的专栏
03-24 1821
今天和朋友聊天，说是阿里有道面试题。 已知一颗完全二叉树，有N个节点 求最后一个节点，亦即最后一排最右边的那个节点。 节点数目2^0+……2^(k-1)>=N >= 2^0+2^1+2^2+2^3……2^k 那么树深为k+1，最后个节点在最后层为第（N-2^0+……2^(k-1)）个 如果（N-2^0+……2^k-1）>2^k/2，那么在右子树，右子树有N-2^(k-1)个节点,； 如
二叉树的遍历-Java语言实现
jinxilongjxl的博客
09-25 173
假设目前有如下所述的二叉树 前序遍历：根，左，右 [7 10 13 6 12 2 5] 中序遍历：左，根，右 [13 10 6 7 2 12 5] 后序遍历：左，右，根 [13 6 10 2 5 12 7] 树节点的定义 /** * 树节点的定义 */ public class TreeNode { // 数据域 int val; // 左树节点 TreeNode left; // 右树节点 TreeNode right; // 通过此构造方法给节点的数据域传值 public Tre
2024年最全Python 实现二叉树前序，中序，后序，层次遍历，把面试官逗笑了
最新发布
m0_60635176的博客
05-10 813
如果你也是看准了Python，想自学Python，在这里为大家准备了丰厚的免费大礼包，带大家一起学习，给大家剖析Python兼职、就业行情前景的这些事儿。
完全二叉树的节点个数
lishuangzhi的博客
08-06 969
2021年8月5日 leetcode 222题 给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。 完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。 入门 看到这题, 很容易想到用深搜或广搜求解 ,然而, 同样时间复杂度的递归分治解法更加简单 递归实现, 时间和空间复杂度都是O(n) func countNodes(root *TreeNo
数据结构C语言严蔚敏版(第二版)超详细笔记附带课后习题
热门推荐
chongyang_的博客
11-07 26万+
根据此书所做随笔笔记。 一、绪论 1.1、数据机构的研究内容 用计算机解决实际问题时，步骤：首先分析实际问题，从中抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编程，调试，测试。 寻求数据模型的实质是分析问题，从中提取出计算机处理的对象，并找出这些对象之间的关系，然后用数学的语言加以描述。 关键：分析问题中所用到的数据是如何组织的，研究数据之间存在什么样的关系。 由于数据必须在计算机中处理，因此不能局限于数据本身的数学问题的研究，还必须考虑数据的物理结构，即数据在计算机中的存储结构。 1.
【数据结构】二叉树
East-sunrise的博客
10-26 1025
不就二叉树嘛，爬！！！！
leetcode2-BinaryTree:LeetCodeOJ在Python中的二叉树可视化
06-29
leetcode 2 LeetCode 的二叉树 BinaryTree.py是一个方便的工具，它可以构建和显示编码时所需的二叉树 ...python -m unittest -v test LeetCode 二叉树序列化 见，点击“阅读更多关于如何在 OJ 上序列化二叉树”
leetcode和oj-LeetCode:力扣OJ
06-30
在这个名为"leetcode和oj-LeetCode:力扣OJ"的项目中，可能包含了一个GitHub仓库的克隆，名为"LeetCode-master"。这个仓库很可能存储了作者在解决力扣题目时编写的代码以及相应的解题思路和分析。通过这样的分享，...
数据结构与算法Python版第九周OJ作业
01-20
1 二叉树复原（10分） 题目内容： 给定一种序列化二叉树的方式：从根节点起始按层次遍历二叉树所有“可能”...一行合法的Python表达式，可解析为包含整数与None的列表 输出格式： 二叉树中序遍历的整数序列，以空格分隔
leetcodeoj和leetcode-LeetCode:力扣OJ练习
07-07
在LeetCode上，你可以找到不同难度级别的题目，这些题目通常分为以下几个类别：数组、链表、字符串、栈、队列、哈希表、二叉树、回溯、动态规划、图算法等。通过实践这些题目，程序员可以提高对数据结构和算法的理解...
leetcode和oj-LeetCode:力码
06-30
它集合了大量的编程题目，涵盖多种编程语言，包括但不限于C++, Java, Python等。这些题目通常分为不同的难度等级，从基础到进阶，涵盖数据结构、算法、设计模式等多个领域，对于准备面试或提升自身技术实力的开发者...
二叉排序树BST实现笔记
qq_26239785的博客
08-13 317
题目链接 acwing3786 代码 #include<iostream> using namespace std; const int INF=0x3f3f3f3f; struct treenode { int val; treenode *left,*right; treenode(int _val) :val(_val),left(NULL),right(NULL){} }; treenode *root; void insert(treenode *&r
Leetcode---完全二叉树的节点个数
可乐不解渴
08-14 462
????生活，是一种缓缓如夏日流水般的前进，我们不要焦急。
数据结构(树)-随笔
zzsan的博客
02-08 2119
基础概念 树 存储的是具有“一对多”关系的数据元素的集合 树的深度（高度） 从一棵树的树根开始，树根所在层为第一层，根的孩子结点所在的层为第二层，依次类推, 一棵树的深度（高度）是树中结点所在的最大的层次 兄弟节点 都有相同的父结点的子结点 二叉树 满足以下两个条件的树: 本身是有序树； 树中包含的各个节点的度不能超过 2，即只能是 0、1 或者 2； 拥有的子树数（结点有多少分支）称为结点的度（Degree） 二叉树的性质: 二叉树中，第 n 层最多有 2n-1 个结点。 如果二叉树的深度为
【算法简述】基础数据结构-满二叉树
Ampty36的博客
10-06 1081
满二叉树满二叉树定义&性质 满二叉树是是个超级意味深长无敌复杂无可奈何让人超级意味深长无敌复杂无可奈何… 但是国外的二叉树说法就不一样： 但是，我们还是让国内的算法为标准，再说我们讲太多也不好，所以这次我只讲国内的（满二叉树） 满二叉树定义&性质 一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树；如果一个二叉树的层数为k，且结点总数是(2^k) -1，...
【二叉树】基本概念和遍历
皮皮的雅客
11-16 349
二叉树是一种非常重要的数据结构，其在查找、排序等领域有着非常重要的应用。本文简单介绍一些关于二叉树的基本概念，并给出几种二叉树的基本遍历方法。全文代码为Java语言实现。 文章目录二叉树的基本概念1. 二叉树的定义2. 二叉树的性质二叉树的构造与遍历1. 二叉树的构造2. 二叉树的遍历 二叉树的基本概念 1. 二叉树的定义 定义： 二叉树是n(n &amp;amp;gt;= 0)个节点所构成的集合，n=0为...
算法学习打卡day23｜二叉树题目总结
weixin_45124219的博客
10-15 196
int val;什么时候递归函数前加if判断？一般情况来说：如果让空节点（空指针）进入递归，就不加if，此时对于空节点的判断交给函数的退出条件那里了，如果不让空节点进入递归，就加if限制一下， 终止条件也会相应的调整。递归函数什么时候需要返回值，什么时候不需要？如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值。（113.路径总和ii）如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值。（二叉树的最近公共祖先）
期权定价-二叉树python
09-25
期权定价模型中的二叉树是一种常用的方法。它可以在给定期权条件和市场数据的情况下，通过构建二叉树来估计期权的价格。该模型的实现包括以下两个主要步骤：1. 从左到右生成二叉树，即根据期权到期时间和时间步长，构建一个二叉树结构；2. 从右向左计算二叉树上各节点的期权价值，即根据期权的特定定价公式和二叉树结构，逆向计算期权的价值。 在Python中，可以通过编写相应的代码来实现二叉树期权定价模型。具体实现的步骤包括：1. 定义二叉树的节点类；2. 构建二叉树结构；3. 根据期权定价公式计算二叉树上各节点的期权价值。 在实现过程中，可以利用Python中的数据结构和算法库，如列表、循环语句、递归等，来简化代码的编写过程。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lady_killer9

感谢您的打赏，我会加倍努力！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值