二叉查找树（BST）

最新推荐文章于 2022-05-15 17:11:51 发布
最新推荐文章于 2022-05-15 17:11:51 发布
阅读量877 收藏 1
点赞数
分类专栏： c++ 文章标签： c++ 数据结构 二叉查找树

什么是二叉查找树

二叉查找树（Binary Search Tree）又叫二叉排序树（Binary Sort Tree），它是一种数据结构，支持多种动态集合操作，如 Search、Insert、Delete、Minimum 和 Maximum 等。

二叉查找树要么是一棵空树，要么是一棵具有如下性质的非空二叉树：

若左子树非空，则左子树上的所有结点的关键字值均小于根结点的关键字值。

若右子树非空，则右子树上的所有结点的关键字值均大于根结点的关键字值。

左、右子树本身也分别是一棵二叉查找树（二叉排序树）。

可以看出，二叉查找树是一个递归的数据结构，且对二叉查找树进行中序遍历，可以得到一个递增的有序序列。

二叉查找树的C++模板实现文件(BSTree.h)

这里因为是模板类，所以二叉查找树的类的相关实现放在头文件中。

下面是一些二叉查找树的相关方法实现。

/**
 * C++ 语言: 二叉查找树
 */

#ifndef _BINARY_SEARCH_TREE_HPP_
#define _BINARY_SEARCH_TREE_HPP_

#include <iomanip>
#include <iostream>
using namespace std;

template <class T>
class BSTNode{
    public:
        T key;            // 关键字(键值)
        BSTNode *left;    // 左孩子
        BSTNode *right;    // 右孩子
        BSTNode *parent;// 父结点

        BSTNode(T value, BSTNode *p, BSTNode *l, BSTNode *r):
        key(value),parent(p),left(l),right(r) {}
};

template <class T>
class BSTree {
    private:
        BSTNode<T> *mRoot;    // 根结点

    public:
        BSTree();
        ~BSTree();

        // 前序遍历"二叉树"
        void preOrder();
        // 中序遍历"二叉树"
        void inOrder();
        // 后序遍历"二叉树"
        void postOrder();
        // 层序遍历"二叉树"
        void BFS_Tree();

    // 深度
    int deep();

        // (递归实现)查找"二叉树"中键值为key的节点
        BSTNode<T>* search(T key);
        // (非递归实现)查找"二叉树"中键值为key的节点
        BSTNode<T>* iterativeSearch(T key);

        // 查找最小结点：返回最小结点的键值。
        T minimum();
        // 查找最大结点：返回最大结点的键值。
        T maximum();

        // 找结点(x)的后继结点。即，查找"二叉树中数据值大于该结点"的"最小结点"。
        BSTNode<T>* successor(BSTNode<T> *x);
        // 找结点(x)的前驱结点。即，查找"二叉树中数据值小于该结点"的"最大结点"。
        BSTNode<T>* predecessor(BSTNode<T> *x);

        // 将结点(key为节点键值)插入到二叉树中
        void insert(T key);

        // 删除结点(key为节点键值)
        void remove(T key);

        // 销毁二叉树
        void destroy();

        // 打印二叉树
        void print();
    private:
        // 前序遍历"二叉树"
        void preOrder(BSTNode<T>* tree) const;
        // 中序遍历"二叉树"
        void inOrder(BSTNode<T>* tree) const;
        // 后序遍历"二叉树"
        void postOrder(BSTNode<T>* tree) const;
        // 层序遍历"二叉树"
        void BFS_Tree(BSTNode<T>* tree) const;

    //深度
    int deep(BSTNode<T>* tree);

        // (递归实现)查找"二叉树x"中键值为key的节点
        BSTNode<T>* search(BSTNode<T>* x, T key) const;
        // (非递归实现)查找"二叉树x"中键值为key的节点
        BSTNode<T>* iterativeSearch(BSTNode<T>* x, T key) const;

        // 查找最小结点：返回tree为根结点的二叉树的最小结点。
        BSTNode<T>* minimum(BSTNode<T>* tree);
        // 查找最大结点：返回tree为根结点的二叉树的最大结点。
        BSTNode<T>* maximum(BSTNode<T>* tree);

        // 将结点(z)插入到二叉树(tree)中
        void insert(BSTNode<T>* &tree, BSTNode<T>* z);

        // 删除二叉树(tree)中的结点(z)，并返回被删除的结点
        BSTNode<T>* remove(BSTNode<T>* &tree, BSTNode<T> *z);

        // 销毁二叉树
        void destroy(BSTNode<T>* &tree);

        // 打印二叉树
        void print(BSTNode<T>* tree, T key, int direction);
};

/* 
 * 构造函数
 */
template <class T>
BSTree<T>::BSTree():mRoot(NULL)
{
}

/* 
 * 析构函数
 */
template <class T>
BSTree<T>::~BSTree() 
{
    destroy();
}

/*
 * 前序遍历"二叉树"
 */
template <class T>
void BSTree<T>::preOrder(BSTNode<T>* tree) const
{
    if(tree != NULL)
    {
        cout<< tree->key << " " ;
        preOrder(tree->left);
        preOrder(tree->right);
    }
}

template <class T>
void BSTree<T>::preOrder() 
{
    preOrder(mRoot);
}

/*
 * 中序遍历"二叉树"
 */
template <class T>
void BSTree<T>::inOrder(BSTNode<T>* tree) const
{
    if(tree != NULL)
    {
        inOrder(tree->left);
        cout<< tree->key << " " ;
        inOrder(tree->right);
    }
}

template <class T>
void BSTree<T>::inOrder() 
{
    inOrder(mRoot);
}

/*
 * 后序遍历"二叉树"
 */
template <class T>
void BSTree<T>::postOrder(BSTNode<T>* tree) const
{
    if(tree != NULL)
    {
        postOrder(tree->left);
        postOrder(tree->right);
        cout<< tree->key << " " ;
    }
}

template <class T>
void BSTree<T>::postOrder() 
{
    postOrder(mRoot);
}

//层次遍历
template <class T>
void BSTree<T>::BFS_Tree(BSTree * root) const
{
    if(root == NULL)
        return;

    //借助双端队列存储遍历的结点
    deque<T> d;
    d.push_back(root);

    while(d.size())
    {
        BSTree temp = d.front();
        cout << d.front()->data;
        d.pop_front();
        if(temp->Lchild)
            d.push_back(temp->Lchild);
        if(temp->Rchild)
            d.push_back(temp->Rchild);
    }
}

template <class T>
void BSTree<T>::BFS_Tree() 
{
    BFS_Tree(mRoot);
}

/*
 * "二叉树"深度
 */
template <class T>
int BSTree<T>::deep(BSTNode<T>* root) const
{
      if(root == null)  
      {  
          return 0;  
      }  
      else  
      {  
       int lchilddeep = deep(root->left);//求左子树的深度  
       int rchilddeep = deep(root->left);//求右子树的深度  
       return lchilddeep > rchilddeep ? lchilddeep + 1 : rchilddeep + 1;//左子树和右子树深度较大的那个加一等于整个树的深度  
      }  
}

template <class T>
int BSTree<T>::deep() 
{
    deep(mRoot);
}

/*
 * (递归实现)查找"二叉树x"中键值为key的节点
 */
template <class T>
BSTNode<T>* BSTree<T>::search(BSTNode<T>* x, T key) const
{
    if (x==NULL || x->key==key)
        return x;

    if (key < x->key)
        return search(x->left, key);
    else
        return search(x->right, key);
}

template <class T>
BSTNode<T>* BSTree<T>::search(T key) 
{
    search(mRoot, key);
}

/*
 * (非递归实现)查找"二叉树x"中键值为key的节点
 */
template <class T>
BSTNode<T>* BSTree<T>::iterativeSearch(BSTNode<T>* x, T key) const
{
    while ((x!=NULL) && (x->key!=key))
    {
        if (key < x->key)
            x = x->left;
        else
            x = x->right;
    }

    return x;
}

template <class T>
BSTNode<T>* BSTree<T>::iterativeSearch(T key)
{
    iterativeSearch(mRoot, key);
}

/* 
 * 查找最小结点：返回tree为根结点的二叉树的最小结点。
 */
template <class T>
BSTNode<T>* BSTree<T>::minimum(BSTNode<T>* tree)
{
    if (tree == NULL)
        return NULL;

    while(tree->left != NULL)
        tree = tree->left;
    return tree;
}

template <class T>
T BSTree<T>::minimum()
{
    BSTNode<T> *p = minimum(mRoot);
    if (p != NULL)
        return p->key;

    return (T)NULL;
}

/* 
 * 查找最大结点：返回tree为根结点的二叉树的最大结点。
 */
template <class T>
BSTNode<T>* BSTree<T>::maximum(BSTNode<T>* tree)
{
    if (tree == NULL)
        return NULL;

    while(tree->right != NULL)
        tree = tree->right;
    return tree;
}

template <class T>
T BSTree<T>::maximum()
{
    BSTNode<T> *p = maximum(mRoot);
    if (p != NULL)
        return p->key;

    return (T)NULL;
}

/* 
 * 找结点(x)的后继结点。即，查找"二叉树中数据值大于该结点"的"最小结点"。
 */
template <class T>
BSTNode<T>* BSTree<T>::successor(BSTNode<T> *x)
{
    // 如果x存在右孩子，则"x的后继结点"为 "以其右孩子为根的子树的最小结点"。
    if (x->right != NULL)
        return minimum(x->right);

    // 如果x没有右孩子。则x有以下两种可能：
    // (01) x是"一个左孩子"，则"x的后继结点"为 "它的父结点"。
    // (02) x是"一个右孩子"，则查找"x的最低的父结点，并且该父结点要具有左孩子"，找到的这个"最低的父结点"就是"x的后继结点"。
    BSTNode<T>* y = x->parent;
    while ((y!=NULL) && (x==y->right))
    {
        x = y;
        y = y->parent;
    }

    return y;
}

/* 
 * 找结点(x)的前驱结点。即，查找"二叉树中数据值小于该结点"的"最大结点"。
 */
template <class T>
BSTNode<T>* BSTree<T>::predecessor(BSTNode<T> *x)
{
    // 如果x存在左孩子，则"x的前驱结点"为 "以其左孩子为根的子树的最大结点"。
    if (x->left != NULL)
        return maximum(x->left);

    // 如果x没有左孩子。则x有以下两种可能：
    // (01) x是"一个右孩子"，则"x的前驱结点"为 "它的父结点"。
    // (01) x是"一个左孩子"，则查找"x的最低的父结点，并且该父结点要具有右孩子"，找到的这个"最低的父结点"就是"x的前驱结点"。
    BSTNode<T>* y = x->parent;
    while ((y!=NULL) && (x==y->left))
    {
        x = y;
        y = y->parent;
    }

    return y;
}

/* 
 * 将结点插入到二叉树中
 *
 * 参数说明：
 *     tree 二叉树的根结点
 *     z 插入的结点
 */
template <class T>
void BSTree<T>::insert(BSTNode<T>* &tree, BSTNode<T>* z)
{
    BSTNode<T> *y = NULL;
    BSTNode<T> *x = tree;

    // 查找z的插入位置
    while (x != NULL)
    {
        y = x;
        if (z->key < x->key)
            x = x->left;
        else
            x = x->right;
    }

    z->parent = y;
    if (y==NULL)
        tree = z;
    else if (z->key < y->key)
        y->left = z;
    else
        y->right = z;
}

/* 
 * 将结点(key为节点键值)插入到二叉树中
 *
 * 参数说明：
 *     tree 二叉树的根结点
 *     key 插入结点的键值
 */
template <class T>
void BSTree<T>::insert(T key)
{
    BSTNode<T> *z=NULL;

    // 如果新建结点失败，则返回。
    if ((z=new BSTNode<T>(key,NULL,NULL,NULL)) == NULL)
        return ;

    insert(mRoot, z);
}

/* 
 * 删除结点(z)，并返回被删除的结点
 *
 * 参数说明：
 *     tree 二叉树的根结点
 *     z 删除的结点
 */
template <class T>
BSTNode<T>* BSTree<T>::remove(BSTNode<T>* &tree, BSTNode<T> *z)
{
    BSTNode<T> *x=NULL;
    BSTNode<T> *y=NULL;

    if ((z->left == NULL) || (z->right == NULL) )
        y = z;
    else
        y = successor(z);

    if (y->left != NULL)
        x = y->left;
    else
        x = y->right;

    if (x != NULL)
        x->parent = y->parent;

    if (y->parent == NULL)
        tree = x;
    else if (y == y->parent->left)
        y->parent->left = x;
    else
        y->parent->right = x;

    if (y != z) 
        z->key = y->key;

    return y;
}

/* 
 * 删除结点(z)，并返回被删除的结点
 *
 * 参数说明：
 *     tree 二叉树的根结点
 *     z 删除的结点
 */
template <class T>
void BSTree<T>::remove(T key)
{
    BSTNode<T> *z, *node; 

    if ((z = search(mRoot, key)) != NULL)
        if ( (node = remove(mRoot, z)) != NULL)
            delete node;
}

/*
 * 销毁二叉树
 */
template <class T>
void BSTree<T>::destroy(BSTNode<T>* &tree)
{
    if (tree==NULL)
        return ;

    if (tree->left != NULL)
        return destroy(tree->left);
    if (tree->right != NULL)
        return destroy(tree->right);

    delete tree;
    tree=NULL;
}

template <class T>
void BSTree<T>::destroy()
{
    destroy(mRoot);
}

/*
 * 打印"二叉查找树"
 *
 * key        -- 节点的键值 
 * direction  --  0，表示该节点是根节点;
 *               -1，表示该节点是它的父结点的左孩子;
 *                1，表示该节点是它的父结点的右孩子。
 */
template <class T>
void BSTree<T>::print(BSTNode<T>* tree, T key, int direction)
{
    if(tree != NULL)
    {
        if(direction==0)    // tree是根节点
            cout << setw(2) << tree->key << " is root" << endl;
        else                // tree是分支节点
            cout << setw(2) << tree->key << " is " << setw(2) << key << "'s "  << setw(12) << (direction==1?"right child" : "left child") << endl;

        print(tree->left, tree->key, -1);
        print(tree->right,tree->key,  1);
    }
}

template <class T>
void BSTree<T>::print()
{
    if (mRoot != NULL)
        print(mRoot, mRoot->key, 0);
}

#endif

判断一棵二叉树是否为BSTree

限定了子树中节点值的范围，从而每个节点只需访问一次。节点值的初始范围可限定为INT_MIN以及INT_MAX。

//判断是否为BST
bool isBST(Node* node)
{
    return(isBSTUtil(node, INT_MIN, INT_MAX));
}
//如果是一颗二叉查找树，且值范围在[min,max]，则返回true
bool isBSTUtil(Node * node , int min , int max )  
{  
        //空树也是BST  
        if ( node == NULL)  
               return true;  

        //如果节点值违反了最大/最小约束条件，则不是BST  
        if ( node->key < min || node->key > max)  
               return false;  

        //递归检查子树  
        return  isBSTUtil( node->left, min, node->key) &&  
              isBSTUtil( node->right, node->key, max);  
}

方法二：

1) 对树进行中序遍历，将结果保存在temp数组中。
3) 检测temp数组中元素是否为升序排列。如果是，则这棵树为BST.
时间复杂度: O(n)
该方法还可以进一步的优化，我们可以避免使用这个额外的数组。在中序遍历时，可以保存前驱节点，如果当前节点小于前驱节点，则这棵树不是BST.

//判断是否为BST  
bool isBST(Node* root)  
{  
    static Node *prev = NULL;  

    // 中序遍历这棵树，并保存前驱节点至prev中  
    if (root)  
    {  
    if (!isBST(root->left))  
    return false;  

    // 检测节点值的合法性  
    if (prev != NULL && root->key <= prev->key)  
        return false;  

    prev = root;  

    //右子树  
        return isBST(root->right);  
    }  

    return true;  
}
MachineChen
关注
专栏目录
二叉查找树C++实现
12-23
在学习算法过程中自己的代码实现，与大家分享交流。版权所有:miracledan
二叉树学习笔记之二叉查找树（BSTree）
weixin_34119545的博客
05-05 218
二叉查找树即搜索二叉树，或者二叉排序树（BSTree），学习回顾一下有关的知识。 >>关于二叉查找树 二叉查找树（Binary Search Tree）是指一棵空树或者具有下列性质的二叉树： 1. 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 2. 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值； ...
#二叉树#BST tree总结
LYR 的博客
07-25 298
删除二叉搜索树中的节点：https://leetcode-cn.com/problems/delete-node-in-a-bst/ ◼ 二叉搜索树中的搜索：https://leetcode-cn.com/problems/search-in-a-binary-search-tree/ ◼ 二叉搜索树中的插入操作：https://leetcode-cn.com/problems/insert-into-a-binary-search-tree/ ◼ 验证二叉搜索树：https://leetcode-cn.c
树(Tree)——(三)搜索二叉树(BST)插入、查找
chenchen_fcj程序猿的博客
07-29 924
  目录 搜索树的创建和插入（C++） 迭代版 （未用递归）： 递归版： BST的查找： BST寻找最大最小值： 查找父节点：   之前用到的二叉树是基本不用的，只是具备了二叉树的样子。二叉树的作用是为了方便查找，所以我们需要构建一个搜索二叉树。 二叉搜索树(BST，Binary Search Tree），也称二叉排序树或二叉查找树。  二叉搜索树不同于一般的二叉树，它是一种...
树(Tree)——(四)搜索二叉树(BST)查找父节点队列版
chenchen_fcj程序猿的博客
08-12 1675
续上次查找父节点的队列版本。若要看之前的方法点击这里 代码如下： myqueue.h #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; struct TreeNode {      TreeNode* _left;      TreeNode*_right;      int _data; }; struct Node {     Tree...
TreeSWT:利用SWT来图形化显示二叉树 目前支持二叉查找树BST
05-11
`TreeSWT`项目正是一款利用`SWT`（Standard Widget Toolkit）库来实现二叉树图形化的工具，特别针对二叉查找树（Binary Search Tree, BST）进行了优化支持。本文将深入探讨`TreeSWT`的实现原理、功能以及如何在...
二叉查找树BST，可以看看
12-13
二叉查找树（Binary Search Tree，简称BST），是一种特殊的二叉树数据结构，它具有以下特性：对于树中的任意一个节点，其左子树中所有节点的值都小于该节点的值，而右子树中所有节点的值都大于该节点的值。...
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
二叉查找树 减治法——C++代码
05-24
二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉查找树中，对于任意节点，其左子树中的...
树、二叉树、二叉搜索树_检查二叉树是否为BST（二叉搜索树）
cumtb2002的博客
06-25 233
树、二叉树、二叉搜索树Description: 描述： This article describes how to check whether a given tree is BST or not? This problem came in coding round of Microsoft. 本文介绍如何检查给定的树是否是BST ？ 这个问题来自微软的编码回合。 Problem Stat...
二叉搜索树（BST，基本操作实现）
sgh666666的博客
12-12 473
二叉搜索树（Binary Search Tree)也叫做二叉排序树或者二叉查找树。 相比正常的二叉树就是多了一条性质：左子树的键值小于其根节点的键值，右子树反之，左右子树都是二叉搜索树。 主要操作函数：（还是递归递归递归！！！） Position Find( ElementType X, BinTree BST )：从二叉搜索树BST 中查找元素X，返回其所在结点的地址； Posi
04-7tree-BST(二叉搜索树)的操作集
qq_46646740的博客
05-15 312
时间:2.5h 难度: 简单偏中等 Hints: 如何处理 delete() 函数使关键呀！我差点就栽倒这里起不来了！！！ [if I were a teacher] 同学们，delete函数有点难搞哦，复杂情况下需要将被删除节点(记为p)的子树里中序遍历的第一个节点拉上来,但具体怎么拉这个节点很重要，需要耐心地去分析！不妨先将被删除的节点分类， 第I类:没有右子树; 第II类：存在右子树(为什么这么分呢？)； 我们处理第II类时又会发现由两种情况, case1: p(被删除...
二叉搜索树(BST)的基本操作
姿势水平
11-27 1426
二叉树的一个重要应用是查找其中的元素，二叉搜索树则是针对数据的动态查找而设计的一种高效的数据结构类型。二叉搜索树是一种特殊的二叉树，它可以为空；如果不为空，满足以下性质：1. 非空 左子树 的所有键值小于其根结点的键值。2. 非空 右子树 的所有键值大于其根结点的键值。3. 左右子树都是二叉搜索树。 由于定义的不同，二叉搜索树也有一些不同于二叉树的操作函数，本文实现了二叉搜索树的指定元素查找、最小元素查找、最大元素查找、插入和删除元素等功能。
BST、AVL、B-TREE、B+TREE、红黑树
千丈之松的专栏
08-04 618
1：BST 二叉搜索树（左子树值&lt;=根值&lt;=右子树） 1.1 定义 1 首先它也是一个二叉树，故满足递归定义; 2 其次每个节点只存在一个值; 3 需满足左子树值&lt;=根值&lt;=右子树，BST的中序遍历必定是严格递增的。 在实际场景中，用的最多的是二叉平衡树， 一般操作的执行时间福再度为O（lgn）。2.但若是一棵具有n个结点的线性链，则此些操作最坏情况运行时间...
LintCode 1561: BST Node Distance (BST 经典题)
roufoo的博客
12-08 1101
原题如下： 1561. BST Node Distance Given a list of numbers, construct a BST from it(you need to insert nodes one-by-one with the given order to get the BST) and find the distance between two given nodes. E...
（一）BST树（二叉搜索树）
qq_42119136的博客
06-29 5019
（一）BST树（二叉搜索树） 1.BST二叉搜索树 1.1BST树的定义 1 BST树也是一个二叉树，故满足递归定义; 2 其次每个节点只存在一个值; 3 需满足左子树值<=根值<=右子树，故按照中序遍历会得到一个非递减序列。 BST涉及操作主要增，删，查，除了删麻烦一点，其他操作均可递归实现，二叉查找树的一般性质： 1.在一棵二叉查找树上，执行查找、插入、删除等操作，的时间复杂度为O（log2n）。因为，一棵由n个结点，随机构造的二叉查找树的高度为log2n，所以顺理成章，一般操作的执行时间为
BST树的查找
我的读书笔记（2011-2013）
12-15 623
BST树的查找 1  查找思想 首先将给定的K值与二叉排序树的根结点的关键字进行比较：若相等： 则查找成功； ① 给定的K值小于BST的根结点的关键字：继续在该结点的左子树上进行查找； ②   给定的K值大于BST的根结点的关键字：继续在该结点的右子树上进行查找。 2   算法实现 ⑴  递归算法 BSTNode *BST_Serach(BSTNode *T , KeyType ke
BST树
dDANGHUAN的博客
03-07 304
#pragma once template&lt;class Type&gt; class BSTree; template&lt;class Type&gt; class BSTNode { friend class BSTree&lt;Type&gt;; public: BSTNode() :data(0), leftChild(NULL), rightChild(NULL) {} ...
BST二叉查找树（二叉排序树）java
超级无敌菜阿板的博客
07-12 187
1.介绍 1.1定义 二叉查找树（Binary Search Tree），是一种基础数据结构，支持多种动态集合的操作，search，insert，delete，minimum和maxmum 1.2二叉树的性质： 要么是一个空树 要么具备以下性质 （1）若左子树非空，则左子树上的所有节点的关键字值均小于根节点的关键字值； （2）若右子树非空，则右子树上的所有节点的关键字值均大于根节点的关键字值； （3）左右子树也分别是一个二叉查找树 2.二叉查找树的java实现 2.1 二叉查找树节点的定义 publi
二叉查找树（BST）详解与Python实现
二叉查找树（Binary Search Tree，BST），作为一种重要的数据结构，它在计算机科学中扮演着关键角色，特别是在数据存储和检索方面。这种树的每个节点最多有两个子节点——左子节点和右子节点。二叉查找树的主要特性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值