二叉搜索树

已于 2022-06-25 17:21:04 修改
阅读量307 收藏
点赞数
分类专栏： 算法 二叉树 二叉搜索树 文章标签： 算法 数据结构 排序算法
于 2022-06-23 21:57:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiqiangnie/article/details/125435708
版权
本文展示了如何使用C语言实现二叉搜索树，包括建立、遍历、搜索、查找最大值和最小值、获取前置节点和后置节点、插入及删除节点等操作。代码实现包括先序、中序和后序遍历，以及对数组进行排序和快速排序的辅助函数。
摘要由CSDN通过智能技术生成

二叉搜索树的实现

二叉搜索树

使用C语言实现了二叉搜索树，直接贴代码

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define arrsort arrisort
#define NULL ((void *)0)
//定义树节点
struct TreeNode {
    struct TreeNode* pnode;//父节点
    struct TreeNode* lnode;//左孩子节点
    struct TreeNode* rnode;//右孩子节点
    int val;//节点值
};
typedef struct TreeNode Tree;
//树节点占用存储
const int TREE_NODE_SIZE=sizeof(struct TreeNode);
const int INT_SIZE = sizeof(int);
const null = 0;

//声明函数调用
void arrprintf(const int[], int);//数组打印
void arrsort(int arr[], int l, int r);//数组排序
Tree* treeBuild(int val[], int l, int r);//二叉树建立
void treeFree(struct TreeNode* proot);//二叉树资源释放
void treeWalkPre(struct TreeNode* proot,int rflag);//先序遍历
void treeWalkPos(struct TreeNode* proot, int rflag);//后续遍历
void treeWalkIno(struct TreeNode* proot, int rflag);//中序遍历
struct TreeNode* treeSearch(struct TreeNode* p, int key);//二叉树搜索
struct TreeNode* treeMax(struct TreeNode* p);//最大直
struct TreeNode* treeMin(struct TreeNode* p);//最小值
struct TreeNode* treePreNode(struct TreeNode* pnode);//前置节点
struct TreeNode* treeNextNode(struct TreeNode* pnode);//后置节点
void treeInsert(struct TreeNode* proot, struct TreeNode* pnew);//节点新增
struct TreeNode* nodeBuild();//创立node
Tree* treeDelete(struct TreeNode* proot, struct TreeNode* pdelete);

int main(){
    const int arr[] = { 52,23,43,75,0,37,58,76,79,19,31,14,47,92,74,80,32,62,81,51,68,69,26,27,1,16,25,84,78,28,66,59,100,44,15,50,90,73,87,21,39,97,61,63,40,82,30,10,34,12,95,45,56,71,48,91,33,53,46,29,24,4,67,8,99,85,41,55,88,5,2,42,98,11,7,94,60,9,86,38,13,35,3,20,83,70,57,72,54,89,49,64,77,96,22,65,17,18,93,6 };
    //const int arr[] = { 46,59,16,77,36,49,54,38,6,44,21,63,4,62,99,76};
    const arrlen = sizeof(arr) / sizeof(int);//获取数组大小
    int* parr =NULL;
    struct TreeNode* proot;
    struct TreeNode* ptmp;
    struct TreeNode* ptmp2;
    parr = (int*)malloc(INT_SIZE* arrlen);
    int i;
    if (parr == NULL) {
        return 1;
    }
    memcpy(parr, arr, INT_SIZE * arrlen);
    arrsort(parr,0, arrlen -1);
    arrprintf(arr, arrlen);
    arrprintf(parr, arrlen);
    proot= treeBuild(parr,0,arrlen-1);
    //二叉树遍历
    treeWalkIno(proot,1);
    treeWalkPre(proot,1);
    treeWalkPos(proot, 1);
    //二叉树搜索
    ptmp=treeSearch(proot, 100);
    if (!ptmp) {
        printf("treeSearch,100:ptmp == null\n");
    }
    else {
        printf("treeSearch,100:%d\n",ptmp->val);
    }
    ptmp = treeSearch(proot, 77);
    if (!ptmp) {
        printf("treeSearch,77:ptmp == null\n");

    }
    else {
        printf("treeSearch,77:%d\n", ptmp->val);
    }




    ptmp = treeSearch(proot, 68);
    if (!ptmp) {
        printf("treeSearch,68:ptmp == null\n");

    }
    else {
        printf("treeSearch,68:%d\n", ptmp->val);
    }

    //最大值
    ptmp = treeMax(proot);
    if (!ptmp) {
        printf("treeMax:ptmp == null\n");
    }
    else {
        printf("treeMax:%d\n", ptmp->val);
    }
    //最小值
    ptmp = treeMin(proot);
    if (!ptmp) {
        printf("treeMin:ptmp == null\n");
    }
    else {
        printf("treeMin:%d\n", ptmp->val);
    }

    //前置节点
    ptmp = treePreNode(treeSearch(proot, 99));
    if (ptmp != NULL) {
        printf("treePreNode(treeSearch(proot, 99)):%d\n", ptmp->val);
    }
    ptmp = treePreNode(treeSearch(proot, 2));
    if (ptmp != NULL) {
        printf("treePreNode(treeSearch(proot, 2)):%d\n", ptmp->val);
    }
    ptmp = treePreNode(treeSearch(proot, 77));
    if (ptmp != NULL) {
        printf("treePreNode(treeSearch(proot, 77)):%d\n", ptmp->val);
    }
    //后置节点
    ptmp = treeNextNode(treeSearch(proot, 99));
    if (ptmp != NULL) {
        printf("ttreeNextNode(treeSearch(proot, 99)):%d\n", ptmp->val);
    }
    ptmp = treeNextNode(treeSearch(proot, 2));
    if (ptmp != NULL) {
        printf("ttreeNextNode(treeSearch(proot, 2)):%d\n", ptmp->val);
    }
    ptmp = treeNextNode(treeSearch(proot, 77));
    if (ptmp != NULL) {
        printf("ttreeNextNode(treeSearch(proot, 77)):%d\n", ptmp->val);
    }
    //插入节点
    ptmp2=nodeBuild();
    if (ptmp2) {
        ptmp2->val = 100;
        treeInsert(proot, ptmp2);
    }
    //插入节点
    ptmp2 = nodeBuild();
    if (ptmp2) {
        ptmp2->val = 1;
        treeInsert(proot, ptmp2);
    }
    //中序遍历打印详情
    treeWalkIno(proot, 1);
    //
    ptmp = treeSearch(proot,100);
    proot=treeDelete(proot, ptmp);
    printf("treeDelete(proot，100)：\n");
    treeWalkIno(proot, 1);
    printf("\n");
    ///

        //
    ptmp = treeSearch(proot, 1);
    proot = treeDelete(proot, ptmp);
    printf("treeDelete(proot，1)：\n");
    treeWalkIno(proot, 1);
    printf("\n");
    ///
    for (i = 0; i < arrlen; i++) {
        ptmp = treeSearch(proot, arr[i]);
        proot = treeDelete(proot, ptmp);
        printf("treeDelete(proot，%d)：\n",arr[i]);
        treeWalkIno(proot, 1);
        printf("\n");
    }
    //资源释放
    treeFree(proot);
    free(parr);
    return 0;
}
void arrswap(int* arr,int i,int j) {
    int tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}
//快速排序
void arrqsort(int arr[], int l, int r) {
    int key = arr[l];
    int li = l;
    int ri = r;
    if (l >= r) {
        return;
    }
    while (1) {
        //arrprintf(arr, 10);
        while (arr[ri] > key) {
            ri--;
        }
        while (arr[li] <= key && li < ri) {
            li++;
        }
        if (li == ri) {
            break;
        }
        arrswap(arr, li, ri);
    }
    arrswap(arr, l, li);
    arrsort(arr, l, li - 1);
    arrsort(arr, li + 1,r);
}
//插入排序
void arrisort(int arr[], int l, int r) {
    int i = 0, j = 0;
    int tmp = 0;
    for (i = l+1; i <= r; i++) {
        //arrprintf(arr, 10);
        tmp = arr[i];
        for (j = i - 1 ; j >= 0; j--) {
            if (arr[j]>tmp) {
                arr[j+1] = arr[j];
            }else {
                break;
            }
        }
        arr[j + 1] = tmp;

    }
}
void arrprintf(const int valarr[],int vallen) {

    int i;
    printf("arr:");
    for (i = 0; i < vallen; i++) {
        printf("%d ",valarr[i]);
    }
    printf("\n");
}
struct TreeNode* nodeBuild() {
    struct TreeNode* p = (struct TreeNode*)malloc(TREE_NODE_SIZE);
    if (p != NULL) {
        memset(p, 0, TREE_NODE_SIZE);
    }
    return p;
}
Tree* treeBuild(int val[],int l,int r) {
    int mid = (l + r) / 2;

    struct TreeNode* proot = NULL;
    if (l > r) {
        return NULL;
    }

    proot = nodeBuild();

    proot->lnode = treeBuild(val,l,mid-1);

    if (proot->lnode != NULL) {
        proot->lnode->pnode = proot;
    }
    proot->rnode = treeBuild(val, mid + 1, r);
    if (proot->rnode != NULL) {
        proot->rnode->pnode = proot;
    }
    proot->val = val[mid];
    return proot;
}
void treeFree(struct TreeNode* proot) {
    if (proot != NULL) {
        treeFree(proot->lnode);
        treeFree(proot->rnode);
        free(proot);
    }
}
//中序遍历
//打印出來的内容加上 <root>包裹可以查看层次结构
void treeWalkIno(struct TreeNode* proot,int rflag) {
    if (proot != NULL) {
        if (!!rflag) {
            printf("<treeWalkIno>");
        }
        if (proot->lnode != NULL) {
            printf("<lnode>");
            treeWalkIno(proot->lnode,0);
            printf("</lnode>");
        }
        printf("<val>%d</val>", proot->val);
        if (proot->rnode != NULL) {
            //printf("<test>x</test>");
            printf("<rnode>");
            treeWalkIno(proot->rnode,0);
            printf("</rnode>");
        }
        if (!!rflag) {
            printf("</treeWalkIno>");
        }

    }
}
//先序遍历
//打印出來的内容加上 <root>包裹可以查看层次结构
void treeWalkPre(struct TreeNode* proot,int rflag) {
  if (proot != NULL) {
        if (!!rflag) {
            printf("<treeWalkPre>");
        }
        printf("<val>%d</val>", proot->val);
        if (proot->lnode!=NULL) {
            printf("<lnode>");
            treeWalkPre(proot->lnode,0);
            printf("</lnode>");
        }
        if (proot->rnode != NULL) {
            //printf("<test>x</test>");
            printf("<rnode>");
            treeWalkPre(proot->rnode,0);
            printf("</rnode>");
        }
        if (!!rflag) {
            printf("</treeWalkPre>");
        }

    }
}
//后续遍历
//打印出來的内容加上 <root>包裹可以查看层次结构
void treeWalkPos(struct TreeNode* proot,int rflag) {
    if (proot != NULL) {
        if (!!rflag) {
            printf("<treeWalkPos>");
        }
        if (proot->lnode != NULL) {
            printf("<lnode>");
            treeWalkPos(proot->lnode,0);
            printf("</lnode>");
        }
        if (proot->rnode != NULL) {
            //printf("<test>x</test>");
            printf("<rnode>");
            treeWalkPos(proot->rnode,0);
            printf("</rnode>");
        }
        printf("<val>%d</val>", proot->val);
        if (!!rflag) {
            printf("</treeWalkPos>");
        }
    }
}
struct TreeNode* treeSearch(struct TreeNode* p,int key) {
    if (p == NULL) {
        return NULL;
    }
    if (p->val == key) {
        return p;
    }
    else if (p->val > key) {
        return treeSearch(p->lnode,key);
    }
    else {
        return treeSearch(p->rnode, key);
    }

}
struct TreeNode* treeMax(struct TreeNode* proot) {
    struct TreeNode* ptmp= proot;
    if (proot == NULL) {
        return NULL;
    }
    while (ptmp->rnode != NULL) {
        ptmp = ptmp->rnode;
    }
    return ptmp;

}
struct TreeNode* treeMin(struct TreeNode* p) {
    struct TreeNode* ptmp = p;
    if (p == NULL) {
        return NULL;
    }
    while (ptmp->lnode != NULL) {
        ptmp = ptmp->lnode;
    }
    return ptmp;

}
//前置节点
struct TreeNode* treePreNode(struct TreeNode* pnode) {
    struct TreeNode* ptmemp;
    if (pnode == NULL) {
        return NULL;
    }
    if (pnode->lnode) {
        return treeMax(pnode->lnode);
    }
    ptmemp = pnode;
    while (1) {
        if (ptmemp->pnode == NULL) {
            return NULL;
        }
        if (ptmemp->pnode->lnode == ptmemp) {
            ptmemp = ptmemp->pnode;
        }else if (ptmemp->pnode->rnode == ptmemp) {
            return ptmemp->pnode;
        }
    }
}
//后置节点
struct TreeNode* treeNextNode(struct TreeNode* pnode) {
    struct TreeNode* ptmemp;
    if (pnode == NULL) {
        return NULL;
    }
    if (pnode->rnode) {
        return treeMin(pnode->rnode);
    }
    ptmemp = pnode;
    while (1) {
        if (ptmemp->pnode == NULL) {
            return NULL;
        }
        if (ptmemp->pnode->rnode == ptmemp) {
            ptmemp = ptmemp->pnode;
        }
        else if (ptmemp->pnode->lnode == ptmemp) {
            return ptmemp->pnode;
        }
    }
}
void treeInsert(struct TreeNode* proot, struct TreeNode* pnew) {
    struct TreeNode* ptmp0;
    if (proot==NULL) {
        return ;
    }
    ptmp0 = proot;
    while (ptmp0 !=NULL) {
        if (pnew->val > ptmp0->val) {
            if (ptmp0->rnode == NULL) {
                //插到这里来
                ptmp0->rnode = pnew;
                pnew->pnode = ptmp0;
                return;
            }
            else {
                ptmp0 = ptmp0->rnode;
            }
        }
        else {
            if (ptmp0->lnode == NULL) {
                //插到这里来
                ptmp0->lnode = pnew;
                pnew->pnode = ptmp0;
                return;
            }
            else {
                ptmp0 = ptmp0->lnode;
            }

        }
    }
}
//如果删除的是根节点，直接返回新的根节点
//如果删除的不是根节点，返回proot
Tree* treeDelete(struct TreeNode* proot, struct TreeNode* pdelete) {


    //Tree* ptree;//子树
    //struct TreeNode* pback;//备份
    struct TreeNode* pfind;//用于替换的节点信息
    //struct TreeNode* ptmp;
   // struct TreeNode* pnew;
    struct TreeNode* prootNew=proot;
    //标志这个节点是父节点的左节点还是右节点0-左节点，1-右节点
    //int pcflag = 0;

    if (!pdelete) {
        return proot;
    }
    //如果右左节点
    if (pdelete->lnode) {


        pfind =treeMax(pdelete->lnode);

        //最大值为欲删除节点的左节点
        if (pfind == pdelete->lnode) {

            pfind->pnode = pdelete->pnode;//建立子父联系
            pfind->rnode = pdelete->rnode;//建立右子树的关系【这种情况是没有右子树的（pfind == pdelete->lnode）】
            if (pfind->pnode) {

                if (pdelete->pnode->lnode == pdelete) {
                    pdelete->pnode->lnode = pfind;//建立父子联系

                }else {
                    pdelete->pnode->rnode = pfind;//建立父子联系

                }
            }
            if (pfind->rnode) {
                pfind->rnode->pnode = pfind;
            }
            free(pdelete);
            //如果原节点右父节点，则删除的不是根节点
            if (pfind->pnode) {
                return proot;
            }
            else {
                return pfind;
            }
        }
        else {
            //做值的交换，然后递归删除pfind
            pdelete->val = pfind->val;
            treeDelete(pdelete, pfind);
            return proot;
        }
    }
    else if (pdelete->rnode) {

        pfind = treeMin(pdelete->rnode);

        //最大值为欲删除节点的左节点
        if (pfind == pdelete->rnode) {

            pfind->pnode = pdelete->pnode;//建立子父联系
            pfind->lnode = pdelete->lnode;//建立右子树的关系【这种情况是没有右子树的（pfind == pdelete->rnode）】
            if (pfind->pnode) {

                if (pdelete->pnode->lnode == pdelete) {
                    pdelete->pnode->lnode = pfind;//建立父子联系

                }
                else {
                    pdelete->pnode->rnode = pfind;//建立父子联系

                }
            }
            free(pdelete);
            //如果原节点有父节点，则删除的不是根节点
            if (pfind->pnode) {
                return proot;
            }
            else {
                return pfind;
            }
        }
        else {
            //做值的交换，然后递归删除pfind
            pdelete->val = pfind->val;
            treeDelete(pdelete, pfind);
            return proot;
        }
    }
    else {
        if (pdelete->pnode) {
            if (pdelete->pnode->lnode==pdelete) {
                pdelete->pnode->lnode = NULL;
            }
            else {
                pdelete->pnode->rnode = NULL;
            }
            //欲删除的节点既没有左节点也没有右节点，直接返回
            free(pdelete);
            return proot;
        }
        else {
            free(pdelete);
            return NULL;
        }

    }

}
qiqiangnie
关注
专栏目录
二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
weixin_54186646的博客
04-25 8万+
图解二叉排序树（二叉查找树、二叉搜索树）的插入操作、查找操作、删除操作以及完整的代码实现
【二叉搜索树】二叉搜索树的用法以及实现
m0_68617301的博客
04-28 1192
二叉搜索树的用法以及实现
二叉搜索树详解
拂晓123的博客
06-17 5903
写在前面        本文主要分为三个部分。        第一部分介绍了二叉搜索树的基本性质。        第二部分全面详细地讲述了二叉搜索树的各种基本操作...
【Java 数据结构】实现一个二叉搜索树
程序猿教你打篮球的博客
01-09 7035
本期主要讲解： 1、认识二叉搜索树 2、实现一个二叉搜索树 2.1 成员变量 2.2 insert 方法 2.3 search 方法 2.4 remove 方法(重点) 3、二叉搜索树总结
二叉搜索树（BinarySearchTree）
潜心钻研技术
03-05 1707
二叉搜索树（BinarySearchTree） 文章目录二叉搜索树（BinarySearchTree）二叉搜索树的概念如何定义 二叉搜索树的节点 && 二叉搜索树查找插入删除二叉搜索树的缺点二叉搜索树的应用 二叉搜索树的概念 搜索二叉树满足一下条件： 是一棵二叉树 这可树上的任意一个节点满足：若他的右子树不为空，则右子树上的所有节点的值大于该节点的值 这可树上的任意一个节点满足：若他的左子树不为空，则左子树上的所有节点的值小于该节点的值 它的的左子树和右子树也是二叉搜索树 例如下图就是一
java二叉搜索树详解
m0_57180439的博客
02-21 2191
文章目录一、概念二、相关操作1.查找2.插入2.删除实现 提示：以下是本篇文章正文内容，下面案例可供参考 一、概念 二叉搜索树又称二叉排序树 它或者是一棵空树，或者是具有以下性质的二叉树: 1.若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 2.若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 3.它的左右子树也分别为二叉搜索树 （图片来自比特就业课） 二、相关操作 1.查找 （图片来自比特就业课） 代码如下（示例）： 2.插入 代码如下（示例）： 2.删除 实现 ....
C++ 二叉搜索树 详细讲解
foodsx的博客
05-29 1051
C++ 二叉搜索树 详细讲解
判断二叉树是否为二叉搜索树
明朗晨光的专栏
07-01 5908
利用二叉树递归套路判断是否为二叉搜索树
二叉搜索树代码实现
weixin_66404215的博客
01-29 1705
二叉搜索树代码实现
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树、实现搜索、插入、删除的操作实例 Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值...
c代码-二叉搜索树的删除操作
07-14
在IT领域，二叉搜索树（Binary Search Tree，简称BST）是一种常见的数据结构，它具有很多优秀的特性，比如快速的查找、插入和删除操作。在实际应用中，我们经常需要对BST进行各种操作，其中删除操作是相对复杂的一个...
树-98. 验证二叉搜索树-PYTHON
01-20
在二叉搜索树（Binary Search Tree，BST）中，每个节点的值必须满足以下规则：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而其右子树中的所有节点的值都大于该节点的值。在给定的题目“树-98. 验证...
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
LeetCode-12. 整数转罗马数字【哈希表 数学 字符串】
zik的博客
10-08 826
如果该值以 4 或 9 开头，使用 减法形式，表示从以下符号中减去一个符号，例如 4 是 5 (V) 减 1 (I): IV ，9 是 10 (X) 减 1 (I)：IX。仅使用以下减法形式：4 (IV)，9 (IX)，40 (XL)，90 (XC)，400 (CD) 和 900 (CM)。你不能多次附加 5 (V)，50 (L) 或 500 (D)。如果该值不是以 4 或 9 开头，请选择可以从输入中减去的最大值的符号，将该符号附加到结果，减去其值，然后将其余部分转换为罗马数字。
二叉树系列 10/11
最新发布
2301_78191305的博客
10-11 408
在这些路径中，只有红色和绿色的路径是伪回文路径，因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ，绿色路径 [2,1,1] 存在回文排列 [1,2,1]。总共有 3 条从根到叶子的路径：红色路径 [2,3,3] ，绿色路径 [2,1,1] 和路径 [2,3,1]。（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）（一个节点的祖父节点是指该节点的父节点的父节点。」的，当它满足：路径经过的所有节点值的排列中，存在一个回文序列。
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 1007
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
成绩分析报告中的统计指标算法
weixin_58444518的博客
10-08 822
考生总分大于等于满分乘以优秀率，该考生成绩即为优秀，良好、及格和不及格与优秀等级处理方式相同，低分指考生总分小于等于满分乘以低分率，该考生成绩为低分。成绩分析报告中涉及到很多统计指标，包括满分、平均分、最高分、最低分、得分率、难度、区分度、标准差、标准分、信度等，下面将概念较复杂的指标进行简单说明。其中R为信度系数，K为整份试卷的题目数，Si×Si为所有考生在第i题得分的方差，S×S为所有考生所得总分的方差。表示全体考生分数的均值，S表示考生分数的标准差，Z为某考生分数对应的标准分数。
无人机航拍视频帧处理与图像拼接算法
mingo_敏
10-08 385
无人机航拍视频帧处理与图像拼接算法。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值