数据结构——树

于 2024-08-30 21:04:27 发布
阅读量1.1k 收藏 24
点赞数 11
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qixi_ao/article/details/141727274
版权

文章目录

二叉树和BST

树与二叉树

基本概念

树是一种非线性结构，其严格的数学定义是：如果一组数据中除了第一个节点（第一个节点称为根节点，没有直接前驱节点）之外，其余任意节点有且仅有一个直接前驱，有零个或多个直接后继，这样的一组数据形成一棵树。这种特性简称为一对多的逻辑关系。即用于描述具有层次关系，类似组织架构关系的一种数据结构。

树的组成：根，分支，叶子

常见例子

日常生活中，很多数据的组织形式本质上是一棵树。比如一个公司中的职员层级关系，一个学校中的

院系层级关系，淘汰赛中的各次比赛队伍，一个家族中的族谱成员关系等，这些都是树状逻辑结构。

由于树状结构表现出来都是具有层次的，因此也被称为层次结构。

相关术语

通常，在逻辑上表达一棵抽象的树状结构的时候，习惯于将树根放在顶部，树枝树杈向下生长，如下图所示。

请添加图片描述

对于一棵树来说，有如下基本术语：

  1. 结点：

树中的元素 及其子树

  1. 根（root）：

树的第一个节点，没有直接前驱。如上图中的A。

  1. 双亲节点**/**父节点（parent）：

某节点的直接前驱称为该节点的双亲节点，或成为父节点。例如上图中A是B的父节点。

  1. 孩子节点**/**子节点（child）：

某节点的直接后继称为该节点的孩子节点。例如上图中B、C、D均为A的孩子节点。

  1. 节点的层次（level）：

根节点所在的层次规定为第1层，其孩子所在的层次为第2层，后代节点以此类推。比如上图中节点E的层次是3。

  1. 节点的度（degree）：

一个节点拥有的孩子节点的总数，称为该节点的度。比如上图中节点B的度为2。

  1. 叶子（leaf）：

一棵树中度等于0的节点，被称为叶子，又称为终端节点。比如上图中K、L、F、G、M、I、J均为

叶子。

  1. 树的高度（height）：

一棵树中所有节点的层次的最大值，称为这棵树的高度，又称为树的深度。比如上图的树的高度为4。

  1. 有序树与无序树：

一棵树中，如果某个节点的孩子节点之间是有次序的，则称这棵树为有序树，反之称为无序树。

二叉树

在各种不同的树状结构中，最常见也最重要的是二叉树（Binary Tree），下面是二叉树的定义：

  • 有序树
  • 任意节点的度小于等于2

比如如下这棵树就是一棵二叉树。其中8是根节点，14是10的右孩子（因为二叉树是有序树，因此严格区分左右），而13则是14的左孩子。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

为了方便对二叉树进行操作，通常会对一棵它进行标号：从上到下，从左到右进行标号：

注意： 没有孩子节点的地方也要标出来

对于二叉树而言，有如下特性：

  1. 第𝑖层上，最多有2𝑖−1个节点。
  2. 高度为𝑘的二叉树，最多有2𝑘−1个节点。
  3. 假设叶子数目为𝑛0，度为2的节点数目为𝑛2，则有：

二叉树的一般结构：

  • 满二叉树

一棵深度为k，且有92^(k-1)$个结点的二叉树，称为满二叉树。这种树的特点是每一层上的结点数都是最大结点数。

简单理解： 除了叶子节点之外，其余节点的度都为2；其特点是： 如果深度为 K，则节点数为 2^K-1。

请添加图片描述

  • 完全二叉树

在一棵二叉树中，除最后一层外，若其余层都是满的，或者最后一层是满的，或者是最后一层在右边缺少连续若干结点，则此二叉树为完全二叉树。

简单理解：除最后一层叶子节点外。是一颗满二叉树，最后一层由右向左有连续缺省的0个,1个或多个节点。

请添加图片描述

  • 二叉搜索树(BST)

特点：

  1. 如果节点具有左子树，则左子树上所有节点都不大于该节点的值；
  2. 节点具有右子树，则右子树上所有节点都不小于该节点的值；
  3. 子树又是二叉搜索数

请添加图片描述

二叉搜索树（BST）

二叉树（BST）的组成

  • 根指针：指向根节点的指针变量

  • 节点：

    • 数据域 (存储的实际数据)
    • 指针域 (左，右指针)

    结构设计：

    typedef int data_t;
typedef struct _node
{
    data_t data; // 数据域
    struct _node *left; // 左子树指针
    struct _node *right;// 右子树指针
}NODE;

二叉树（BST）的算法

  • 创建二叉树

    int btree_create(NODE** root,data_t data);

  • 二叉树数据添加

    int btree_add(NODE** root,data_t data);

    示例图：

请添加图片描述

  • 二叉树数据遍历

    • 前序遍历（先序遍历，即 根左右 )）

      void Preorder(const NODE* root); 1

      前序遍历通俗的说就是从二叉树的根结点出发，先输出根结点数据，然后输出左结点，最后输出右结点的数据。

​ 请添加图片描述

从根结点出发，则第一次到达结点A，故输出A;继续向左访问，第一次访问结点B，故输出B；按照同样规则，输出D，输出H；当到达叶子结点H，返回到D，此时已经是第二次到达D，故不在输出D，进而向D右子树访问，D右子树不为空，则访问至I，第一次到达I，则输出I；I为叶子结点，则返回到D，D左右子树已经访问完毕，则返回到B，进而到B右子树，第一次到达E，故输出E；向E左子树，故输出J；按照同样的访问规则，继续输出C、F、G。

前序遍历输出结果：ABDHIEJCFG

    • 中序遍历（即 左根右 ）
    void Midorder(const NODE* root);

    中序遍历通俗的说就是从二叉树的根结点出发，先输出左结点数据，然后输出根结点，最后输出右结点的数据。

    从根结点出发，则第一次到达结点A，不输出A，继续向左访问，第一次访问结点B，不输出B；继续到达D，H；到达H，H左子树为空，则返回到H，此时第二次访问H，故输出H；H右子树为空，则返回至D，此时第二次到达D，故输出D；由D返回至B，第二次到达B，故输出B；按照同样规则继续访问，输出J、E、A、F、C、G；

    中序遍历输出结果：HDIBJEAFCG

    • 后序遍历（即 左右根 ）

      void Postorder(const NODE* root);

      后序遍历通俗的说就是从二叉树的根结点出发，先输出左结点数据，然后输出右结点，最后输出根结点的数据。

      从根结点出发，则第一次到达结点A，不输出A，继续向左访问，第一次访问结点B，不输出

      B；继续到达D，H；到达H，H左子树为空，则返回到H，此时第二次访问H，不输出H；H右子树为空，则返回至H，此时第三次到达H，故输出H；由H返回至D，第二次到达D，不输出D；继续访问至I，I左右子树均为空，故第三次访问I时，输出I；返回至D，此时第三次到达D，故输出D；按照同样规则继续访问，输出J、E、B、F、G、C，A；

      后序遍历输出为： HIDJEBFGCA

  • 二叉树数据查询

    NODE* btree_find(const NODE* root,data_t data);

    1. 从根结点出发

    2. 如果比根节点小，那么就去其左子树找

    3. 如果比根节点大就去其右子树找

    4. 找到叶子都没找到， 就代表查找失败

  • 二叉树数据更新

    int btree_update(const NODE* root,data_t old,data_t newdata);

  • 二叉树回收

    void btree_destroy(NODE** root);

  • 二叉树数据删除

    int btree_delete(NODE** root,data_t data);

    原则：将待删除的节点尽量转换为删除叶子节点，因为删除叶子节点对BST树影响是最小的；

    思路：

    ① 从根节点开始遍历BST找到待删除的节点；

    ② 对待删除的节点状态进行判断，如果节点有左子树，找到左子树中最大的节点，然后利用

    左子树中最大的节

    点数据替换待删除的节点数据，删除左子树中最大的节点；左子树中最大的节点大概率

    是叶子节点。

    ③ 如果节点只有右子树，找到右子树中最小的节点，然后 利用右子树中最小的节点数据替

    换待删除的节点数

    据，删除右子树中最小的节点；右子树中最小的节点大概率是叶子节点。

    ④ 如果待删除节点是叶子节点，直接删除。

二叉树（BST）完整实现

  • btree.h

    #ifndef __BTREE_H
#define __BTREE_H
typedef int data_t;
typedef struct _node
{
    data_t data; // 节点上的数据
    struct _node *left; // 该节点左侧子节点的地址
    struct _node *right;// 该节点右侧子节点的地址
}NODE;
// 创建搜索二叉树
int btree_create(NODE** root,data_t data);
// 二叉树数据添加
int btree_add(NODE** root,data_t data);
// 二叉树数据删除
int btree_delete(NODE** root,data_t data);
// 二叉树前序遍历
void Preorder(const NODE* root);
// 二叉树中序遍历
void Midorder(const NODE* root);
// 二叉树后序遍历
void Postorder(const NODE* root);
// 二叉树层序遍历
void Levelorder(const NODE* root);
// 二叉树数据查询
NODE* btree_find(const NODE* root,data_t data);
// 更新二叉树数据old 为 newdata
int btree_update(const NODE* root,data_t old,data_t newdata);
// 二叉树回收
void btree_destroy(NODE** root);
#endif

  • btree.c

    #include "btree.h"

/**
 * @function:   int btree_create(NODE** root,DATA data)
 * @brief:      创建搜索二叉树（BST）
 * @argument:
 *              root：根指针地址
 *              data：存储的数据
 * @return:
 *              成功：0
 *              失败  -1
 */
int btree_create(NODE * *root, DATA data)
{
    // 校验根节点是否存在
    if (*root)
    {
        return -1;
    }

    // 创建一个节点并申请内存
    NODE *p = (NODE *)malloc(sizeof(NODE));
    if (!p)
    {
        return -1;
    }

    // 初始化根节点
    p->data = data;
    p->left = p->right = NULL;

    // 将新创建的节点作为根节点
    *root = p;

    return 0;
}

/**
 * @function:   int btree_add(NODE** root,DATA data)
 * @brief:      向搜索二叉树添加数据
 * @argument:
 *              root：根指针地址
 *              data：存储的数据
 * @return:
 *              成功：0
 *              失败  -1
 */
int btree_add(NODE **root, DATA data)
{
    // 创建一个新节点并申请内存
    NODE *pNew = (NODE *)malloc(sizeof(NODE));
    if (!pNew)
    {
        return -1;
    }

    // 给新节点赋初值
    pNew->data = data;
    pNew->left = NULL;
    pNew->right = NULL;

    // 创建一个变量p，用来记录插入位置，变量q，用来记录尾结点（叶子）指针尾随
    NODE *p = *root, *q = NULL;

    // 判断传进来的树是否为空
    if (!p)
    {
        // 将刚刚插入的节点作为根节点
        *root = pNew;
        return 0;
    }

    // 树不为空，并且可能会有多个子节点
    while (p)
    {
        q = p;

        // 校验，如果新节点的值小于当前节点的值，就指向left，否则指向right，关于等于的情况，自行划分
        if (memcmp(&data, &(p->data), sizeof(DATA)) < 0)
        {
            p = p->left;
        }
        else
        {
            p = p->right;
        }
    }

    // 执行完上面循环，就找到了插入节点的前一个节点的位置q

    if (memcmp(&data, &(q->data), sizeof(DATA)) < 0)
    {
        q->left = pNew;
    }
    else
    {
        q->right = pNew;
    }

    return 0;
}

/**
 * @function:   void Preorder(const NODE* root)
 * @brief:      二叉树数据遍历（前序遍历-根左右）
 * @argument:
 *              root：根指针地址
 * @return:     无
 *
 */
void Preorder(const NODE *root)
{
    // 此处判断不仅仅用来校验树是否为空，同时也作为递归的跳出的条件
    if (!root)
    {
        return;
    }
    // 输出我们找到的数据
    printf("%4d", root->data); // 根
    Preorder(root->left);      // 左
    Preorder(root->right);     // 右
}

/**
 * @function:   void Midorder(const NODE* root)
 * @brief:      二叉树的遍历（中序遍历-左跟右）
 * @argument:
 *              root：根指针地址
 * @return:     无
 *
 */
void Midorder(const NODE *root)
{
    // 此处需要控制递归的跳出
    if (!root)
    {
        return;
    }
    Midorder(root->left);      // 左
    printf("%4d", root->data); // 根
    Midorder(root->right);     // 右
}

/**
 * @function:   void Postorder(const NODE* root)
 * @brief:      二叉树的遍历（后序遍历-左右根）
 * @argument:
 *              root：根指针地址
 * @return:     无
 *
 */
void Postorder(const NODE *root)
{

    // 此处需要控制递归的跳出
    if (!root)
    {
        return;
    }

    Postorder(root->left);     // 左
    Postorder(root->right);    // 右
    printf("%4d", root->data); // 根
}

/**
 * @function:   NODE* btree_find(const NODE* root,DATA data)
 * @brief:      二叉树数据查询
 * @argument:
 *              root：根指针地址
 * @return:     无
 */
NODE *btree_find(const NODE *root, DATA data)
{
    // 创建一个变量，用来接收传进来的节点
    const NODE *p = root;

    while (p)
    {
        if (memcmp(&data, &(p->data), sizeof(DATA)) < 0)
        // if(data < p->data)
        {
            p = p->left;
        }
        else if (memcmp(&data, &(p->data), sizeof(DATA)) > 0)
        {
            p = p->right;
        }
        else
        {
            return (NODE *)p;
        }
    }
    return NULL;
}

/**
 * @function:   int btree_update(const NODE* root,DATA old,DATA newdata)
 * @brief:      更新二叉树的数据old 为 newdata
 * @argument:
 *              root：根指针地址
 *              old：源数据
 *              newdata：目标数据
 * @return:     无
 */
int btree_update(const NODE *root, DATA old, DATA newdata)
{
    // 获取old数据对应的节点
    NODE *pFind = btree_find(root, old);
    // 校验
    if (!pFind)
    {
        return -1;
    }
    // 修改节点上的数据
    pFind->data = newdata;

    return 0;
}

/**
 * @function:   static void btree_free(NODE** root)
 * @brief:      二叉树回收
 * @argument:
 *              root：根指针地址
 * @return:     无
 */
static void btree_free(NODE *root)
{
// 递归跳出的条件
    if (!root)
    {
        return;
    }
    btree_free(root->left);  // 左
    btree_free(root->right); // 右
    // 内存释放
    free(root);
}

/**
 * @function:   void btree_destroy(NODE** root)
 * @brief:      二叉树回收
 * @argument:
 *              root：根指针地址
 * @return:     无
 */
void btree_destroy(NODE **root)
{
    // 定义一个回收函数，递归的去回收每一个节点
    btree_free(*root);
    *root = NULL;
}

/**
 * @function:   int btree_delete(NODE** root,DATA data)
 * @brief:      二叉树数据删除
 * @argument:
 *              root：根指针地址
 *              data：源数据   source,target
 * @return:     无
 */
int btree_delete(NODE **root, DATA data)
{
    NODE *del = *root;    // 指向待删除的节点  p
    NODE *parent = NULL;  // 指向实际删除节点的父节点 q
    NODE *replace = NULL; // 指向实际删除的节点

    while (del)
    {
        if (memcmp(&(del->data), &data, sizeof(DATA)) < 0)
        {
            parent = del;
            del = del->right;
        }
        else if (memcmp(&(del->data), &data, sizeof(DATA)) > 0)
        {
            parent = del;
            del = del->left;
        }
        else // 找到了待删除的节点
        {
            if (del->left) // 待删除的节点有左子树
            {
                // 如果有左子树，找左子树中最大的节点
                parent = del;
                replace = del->left;
                // 通过一个循环，找左子树中最大的节点
                while (replace->right)
                {
                    parent = replace;
                    // 控制左子树的循环条件
                    replace = replace->right;
                }
                // 循环跳出，代表已经找到了最大的子节点
                // 将我们找到的最大字节点的数据赋值给待删除节点
                del->data = replace->data;

                if (parent->right = = replace) // 实际删除的节点在父节点的右子树上
                {
                    // 如果实际删除节点（replace）是叶子节点，就赋值为NULL，如果不是，就改变引用关系
                    parent->right = replace->left;
                }
                else
                {
                    parent->left = replace->left;
                }
                free(replace);
            }
            else if (del->right) // 待删除的节点只有右子树
            {
                // 如果仅有右子树，找右子树中最小的节点
                parent = del;
                replace = del->right;
                // 通过一个循环，找右子树中最小的节点
                while (replace->left)
                {
                    parent = replace;
                    replace = replace->left;
                }
                // 数据替换
                del->data = replace->data;

                if (parent->right == replace)
                    parent->right = replace->right;
                else
                    parent->left = replace->right;

                free(replace);
            }
            else // 待删除的节点是叶子节点
            {
                if (!parent)
                {
                    free(del);
                    *root = NULL;
                    return 0;
                }
                // 解除父节点和被删节点的引用关系
                if (parent->left == del)
                {
                    parent->left = NULL;
                }
                else
                {
                    parent->right = NULL;
                }
                free(del);
            }
            return 0;
        }
    }
    return -1;
}
qixi_ao
关注
专栏目录
数据结构—树形结构
3166375975@的博客
09-25 7600
树的概念  由N（N&gt;=0）个节点组成的集合。对N &gt; 1的树，有： 有一个特殊的结点，称为根结点，根节点没有前驱结点 除根结点外，其余结点被分成M(M&gt;0)个互不相交的集合T1、T2、 ……、Tm，其中每一个集合Ti(1&lt;= i &lt;= m)又是一棵结构与树类似 的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继 因此，树是递归定义的。 结...
【数据结构与算法】树(Tree)【详解】
DreamSun的博客
03-25 6063
【知识框架】树是n（n>=0）个结点的有限集。当n = 0时，称为空树。有且仅有一个特定的称为根的结点。当n>1时，其余节点可分为m（m>0）个互不相交的有限集T1,T2,…,Tm，其中每个集合本身又是一棵树，并且称为根的子树。显然，树的定义是递归的，即在树的定义中又用到了自身，树是一种递归的数据结构。树的根结点没有前驱，除根结点外的所有结点有且只有一个前驱。树中所有结点可以有零个或多个后继。因此n个结点的树中有n-1条边。
数据结构-树
最新发布
Alaskan_Husky的博客
12-09 1056
树是一种层次结构的数据结构，由节点和边组成。每个节点有一个父节点和零个或多个子节点。树结构常用于表示层次关系，如文件系统、组织结构等。节点的最上层称为根节点，没有子节点的节点称为叶子节点。在树结构中，节点之间不能形成环路。常见的树结构包括二叉树、二叉搜索树、平衡树等。
【数据结构】-树形结构概述和操作
努力的里
09-02 1266
树形结构是数据结构中的一种逻辑关系结构，在此逻辑结构中数据元素之间满足一对多的分层结构关系，也称分层结构。1.所有的数据节点中的起始节点，有且仅有一个，也称为根节点。没有直接前驱，可以有多个直接后继节点。2.末尾节点，可以有一个或者多个，也称为叶节点，或者树叶。每一个节点没有直接后继节点，有且仅有一个直接前驱节点。3.中间的节点，也称为内部节点。每一个节点有且仅有一个直接前驱节点；可以有多个直接后继节点。树是n个节点的有序集合，它满足两个条件：1.有且仅有一个特定的根节点；
数据结构——树形结构
qq_53309469的博客
09-15 537
树（Tree）是n（n≥0）个节点的有限集合T，它满足两个条件 ：有且仅有一个特定的称为根（Root）的节点；其余的节点可以分为m（m≥0）个互不相交的有限集合T1、T2、……、Tm，其中每一个集合又是一棵树，并称为其根的子树（Subtree）。//左子树//数据//右子树}BTree;
自定义数据结构——树 v1.1.zip
06-03
实现了一个自定义的数据结构 —— 树，该自定义结构不同于二叉树及其他数据结构，每个节点的子节点个数不受限制，最大限度保留了数据的原始结构，并实现了其前序和后序遍历的方法。优点是节省了内存，但缺点则是基于...
C语言数据结构——树
01-10
C语言数据结构，树相关知识，整理了一段时间，差不多有个雏形，大家可以参考学习。
【C++】数据结构——树与二叉树（各类函数汇总）
07-29
包含各种有关树与二叉树的函数，有：二叉树的链表实现相关函数、二叉树的静态实现相关函数、二叉树遍历相关函数、树的存储与遍历相关函数。这些函数都是模板格式，可以根据您的需求自由更改、运用。本资源适合各年龄...
数据结构中的树结构详细解释
09-20
数据结构中的树结构详细解释数据结构中的树结构详细解释
数据结构：树(Tree)【详解】
热门推荐
UniqueUnit的博客
02-26 16万+
树 一、知识框架 二、考纲内容 树的基本概念 二叉树 二叉树的定义及其主要特征；二叉树的顺序存储结构和链式存储结构；二叉树的遍历；线索二叉树的基本概念和构造 树、森林 树的存储结构；森林与二叉树的转换；树和森林的遍历 树与二叉树的应用 二叉排序树；平衡二叉树；哈夫曼树和哈弗编码 三、树的基本概念 1、树的定义 树是n（n>=0）个结点的有限集。当n = 0时，称为空树。在任意一棵非空树中应满足： 有且仅有一个特定的称为根的结点。 当n>1时，其余节点可分为m（m>
[数据结构] 常用的树型结构
liuyongjie1992的博客
11-08 4189
什么是树： 特点是根节点+叶子节点组成，可以有2叉、3叉、N叉 AVL树、红黑树
数据结构中的各种树浅谈
weixin_30322405的博客
09-16 219
数据结构中为了存储和查找的方便，用各种树结构来存储文件，本章就浅谈一下各种树的表示方法、特点及各自的用途，本章设计的树结构包括：二叉查找树（二叉排序树）、平衡二叉树（AVL树）、红黑树、B-树、B+树、字典树（trie树）、后缀树、广义后缀树。 1、二叉查找树（二叉排序树） 　　（图a） 二叉查找树是一种动态查找表（图a），具有这些性质：...
java中的数据结构——树
lx_Frolf的博客
10-22 6228
树 树形结构是一种层级式的数据结构，由节点和连接它们的边组成， java语言编写的程序中常常用引用来表示边。根是树中顶端的节 点：它没有父节点。节点表示保存在树中的数据对象。非平衡树是 指根左边的后代比右边多，或者相反。 区分树和图的主要特征是树中不存在环路。 树的节点 Root,parent,child,leaf,sibling 。 树的主要类型 N元树 平衡树 二叉树 二叉搜索树 AVL树 红...
【数据结构】数据结构中常用的树
长相忆兮长相忆的专栏
07-31 2万+
声明：本文汇总了数据结构中一些常用的树，主要内容来自《数据结构（严蔚敏版）》和《算法导论》这两本教材。本文主要归纳出数据结构中常见的树的概念与简单的性质，并未给出具体的操作，如插入、删除、查找等。1、树的定义首先给出树的相关定义：树（tree）是包含n（n>0）个结点的有穷集，其中： 1）每个元素称为结点（node）； 2）有一个特定的结点被称为根结点或树根（root）； 3）除根结点之外的其
数据结构---树（所有类型的树总结）
小皮皮LL的博客
08-11 5718
文章目录数据结构---树1.二叉树2.二叉查找树-BST3.平衡二叉树-AVL4.红黑树5.哈夫曼树6.B树7.B+树8.R树总结 数据结构—树 本章总结数据结构中一些树的特征和结构。转载自这里 1.二叉树 二叉树：最多有两颗子树的树被称为二叉树。 二叉树又分为斜树，满二叉树，完全二叉树： 斜树：所有节点都只有左子树的二叉树叫做左斜树，所有节点都只有右子树的二叉树叫做右斜树。(本质就是链表) 满二叉树：二叉树中所有非叶子结点的度都是2，且叶子结点都在同一层次上。 完全二叉树：如
数据结构-各种树的定义
zeling
01-21 2万+
术语 节点深度：对任意节点x，x节点的深度表示为根节点到x节点的路径长度。所以根节点深度为0，第二层节点深度为1，以此类推 节点高度：对任意节点x，叶子节点到x节点的路径长度就是节点x的高度 树的深度：一棵树中节点的最大深度就是树的深度，也称为高度 父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点 子节点：一个节点含有的子树的根节点称为该节点的子节点 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值