二叉树的操作（C++实现）

已于 2023-12-01 17:18:02 修改
阅读量321 收藏
点赞数 11
分类专栏： 算法 文章标签： c++ 开发语言
于 2023-12-01 16:31:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67656158/article/details/134736921
版权

目录

⚽实现要求：

🏐题目分析： 

🏀代码展示：

📌前提类和函数声明：

🥎模块一（层次—>创建二叉树）：

🎱模块二（三种遍历方式、求树结点数目、求树高）：

❄️模块三（前序中序创建树、层次遍历树）： 

📌完整代码展示（建议先把分模块的代码搞清楚）： 

💓 最后：

⚽实现要求：

  • 实验目的

掌握二叉树的基本概念，二叉树的存储结构使用链表。

  • 实验内容
  1. 输入一个完全二叉树的层次遍历字符串，创建这个二叉树，输出这个二叉树的前序遍历字符串、中序遍历字符串、后序遍历字符串、结点数目、二叉树高度(上述每一个结果独立一行显示)。
  2. 输入二叉树前序序列和中序序列(各元素各不相同)，创建这个二叉树，输出该二叉树的后序序列、层次遍历。

🏐题目分析： 

简单来说实验就是要我们实现三个东西：

一、根据完全二叉树的层次遍历字符串创建这个二叉树。这里这个完全二叉树非常关键，因为如果是一般的二叉树，仅仅有一个层次遍历序列是不能唯一确定一棵二叉树的。

二、前序、中序、后序遍历这个二叉树，然后计算结点数目以及二叉树的高度。这里计算结点数目非常容易，而计算二叉树的高度本质也就是后序遍历的变形。

三、通过一个二叉树的前序序列和中序序列来创建一个二叉树，并后序、层次遍历这个二叉树。这里考察的就是1、根据两个序列创建树。2、层次遍历一棵树

🏀代码展示：

前提类和函数声明：

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

int size=0;
char result[1000];

class TreeNode{//树中的每一个结点类
public:
    char data;
    TreeNode* leftN;
    TreeNode* rightN;
public:
    TreeNode(){
        data=' ';
        leftN=NULL;
        rightN=NULL;
    }
    TreeNode(char a){
        data=a;
        leftN=NULL;
        rightN=NULL;
    }
    TreeNode(char a,TreeNode* l,TreeNode* r){
        data=a;
        leftN=l;
        rightN=r;
    }
};
TreeNode* mTree_pre_in(string a,string s);//两个序列创建树的函数声明
class Tree{//树本身的类
public:
    TreeNode* root;
public:
    Tree(string a,int length){
        if(length<=0)return;
        root=new TreeNode(a[1]);
        createTree(root,1,a);
    }
    Tree(){
        root=NULL;
    }
    Tree(TreeNode* t){
        root=t;
    }
//对树的操作放在树这个类里面
    void createTree(TreeNode* a,int index,string s);//根据层次序列构造树
//下面的遍历函数的参数a表示从哪个位置开始遍历
    void preOrder(TreeNode* a);
    void inOrder(TreeNode* a);
    void proOrder(TreeNode* a);
    void levelOrder(TreeNode* a);
    int height(TreeNode* a);//求树的高度

};

🥎模块一（层次—>创建二叉树）：

//s就是层次序列，index表示从哪个下标结点开始创建（我们肯定是从1开始）
void Tree::createTree(TreeNode* a,int index,string s){
    int length=s.size();
    if(2*index<length){//2*index得到的就是目前index下标对应结点的左节点
        TreeNode* t=new TreeNode(s[index*2]);
        a->leftN=t;
        createTree(a->leftN,index*2,s);
    }
    if(index*2+1<length){2*index+1//得到的就是目前index下标对应结点的右节点
        TreeNode* t=new TreeNode(s[index*2+1]);
        a->rightN=t;
        createTree(a->rightN,index*2+1,s);
    }
}

🎱模块二（三种遍历方式、求树结点数目、求树高）：

//所有遍历的结果存储在result中，注意result应该是一个全局遍历而不是临时变量
//size表示目前result中元素的数目，必须是全局变量，并且在每次遍历后下一个遍历前都要重置为0
void Tree::preOrder(TreeNode* a){//前序遍历
    if(a!=NULL){
        result[size++]=a->data;
        preOrder(a->leftN);
        preOrder(a->rightN);
    }
}
void Tree::inOrder(TreeNode* a){//中序遍历
    if(a!=NULL){
        inOrder(a->leftN);
        result[size++]=a->data;
        inOrder(a->rightN);
    }
}
void Tree::proOrder(TreeNode* a){//后序遍历
    if(a!=NULL){
        proOrder(a->leftN);
        proOrder(a->rightN);
        result[size++]=a->data;
    }
}
int Tree::height(TreeNode* a){
    if(a==NULL)//空结点的树高为0，即叶子结点下面的结点高为0
    return 0;//递归一定要有终止的地方
    else{//每一步重复操作就是递归使用的本质原因
        int leftHeight=height(a->leftN);
        int rightHeight=height(a->rightN);
        if(leftHeight>rightHeight)return ++leftHeight;
        else return ++rightHeight;
    }
}

❄️模块三（前序中序创建树、层次遍历树）： 

//层次遍历树用到了队列这个数据结构，这里不过多解释
void Tree::levelOrder(TreeNode* a){
    if(a==NULL)
        return;
    TreeNode* t=a;
    queue<TreeNode*> q;
    q.push(a);
    while(!q.empty()){
        t=q.front();
        result[size++]=t->data;
        q.pop();
        if(t->leftN)q.push(t->leftN);
        if(t->rightN)q.push(t->rightN);
    }
}
//每次能分析出一个根节点加上左右子树的前后序列，所以每次可以添加一个结点
//创建树的本质就是创建新的结点在合适的位置
TreeNode* mTree_pre_in(string pre,string in,int length){
    if(length==0)//如果前后序列为零，则不用创建
    return NULL;
//前序的第一个元素必定是树的根结点
    TreeNode* root=new TreeNode(pre[1]);
    int count=0;
//找到这个根节点在中序序列中的位置，因为中序序列根节点两边分别是左右子树
    for(int i=1;i<=length;i++){
        if(in[i]==pre[1])
        count=i;
    }
//得到左右子树的长度
    int leftLength=count-1;
    int rightLength=length-count;
//下面“1”+操作是为了让我们每次都是从下标1开始。主要为了方便树的操作
//下面就是分别对左右子树进行递归操作
//分析可得这个操作是前序遍历的一个变型
    if(count!=0){
        root->leftN=mTree_pre_in("1"+pre.substr(2,leftLength),"1"+in.substr(1,leftLength),leftLength);
        root->rightN=mTree_pre_in("1"+pre.substr(2+leftLength,rightLength),"1"+in.substr(count+1,rightLength),rightLength);
    }
    return root;

}

📌完整代码展示（建议先把分模块的代码搞清楚）： 

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

int size=0;
char result[1000];

class TreeNode{
public:
    char data;
    TreeNode* leftN;
    TreeNode* rightN;
public:
    TreeNode(){
        data=' ';
        leftN=NULL;
        rightN=NULL;
    }
    TreeNode(char a){
        data=a;
        leftN=NULL;
        rightN=NULL;
    }
    TreeNode(char a,TreeNode* l,TreeNode* r){
        data=a;
        leftN=l;
        rightN=r;
    }
};
TreeNode* mTree_pre_in(string a,string s);
class Tree{
public:
    TreeNode* root;
public:
    Tree(string a,int length){
        if(length<=0)return;
        root=new TreeNode(a[1]);
        createTree(root,1,a);
    }
    Tree(){
        root=NULL;
    }
    Tree(TreeNode* t){
        root=t;
    }
    void createTree(TreeNode* a,int index,string s);
    void preOrder(TreeNode* a);//下面的遍历函数的参数a表示从哪个位置开始遍历
    void inOrder(TreeNode* a);
    void proOrder(TreeNode* a);
    void levelOrder(TreeNode* a);
    int height(TreeNode* a);

};
TreeNode* mTree_pre_in(string pre,string in,int length){//每次能分析出一个根节点加上左右子树的前后序列，所以每次可以添加一个结点
    if(length==0)//如果前后序列为零，则不用创建
    return NULL;
    TreeNode* root=new TreeNode(pre[1]);
    int count=0;
    for(int i=1;i<=length;i++){
        if(in[i]==pre[1])
        count=i;
    }
    int leftLength=count-1;
    int rightLength=length-count;
    if(count!=0){
        root->leftN=mTree_pre_in("1"+pre.substr(2,leftLength),"1"+in.substr(1,leftLength),leftLength);
        root->rightN=mTree_pre_in("1"+pre.substr(2+leftLength,rightLength),"1"+in.substr(count+1,rightLength),rightLength);
    }
    return root;

}
int Tree::height(TreeNode* a){
    if(a==NULL)//空结点的树高为0，即叶子结点下面的结点高为0
    return 0;//递归一定要有终止的地方
    else{//每一步重复操作就是递归使用的本质原因
        int leftHeight=height(a->leftN);
        int rightHeight=height(a->rightN);
        if(leftHeight>rightHeight)return ++leftHeight;
        else return ++rightHeight;
    }
}
void Tree::createTree(TreeNode* a,int index,string s){
    int length=s.size();
    if(2*index<length){
        TreeNode* t=new TreeNode(s[index*2]);
        a->leftN=t;
        createTree(a->leftN,index*2,s);
    }
    if(index*2+1<length){
        TreeNode* t=new TreeNode(s[index*2+1]);
        a->rightN=t;
        createTree(a->rightN,index*2+1,s);
    }
}
void printNode(char result[],int size){
    for(int i=0;i<size-1;i++){
        cout<<result[i]<<",";
    }
    cout<<result[size-1]<<endl;
}
void Tree::preOrder(TreeNode* a){
    if(a!=NULL){
        result[size++]=a->data;
        preOrder(a->leftN);
        preOrder(a->rightN);
    }
}
void Tree::inOrder(TreeNode* a){
    if(a!=NULL){
        inOrder(a->leftN);
        result[size++]=a->data;
        inOrder(a->rightN);
    }
}
void Tree::proOrder(TreeNode* a){
    if(a!=NULL){
        proOrder(a->leftN);
        proOrder(a->rightN);
        result[size++]=a->data;
    }
}
void Tree::levelOrder(TreeNode* a){
    if(a==NULL)
        return;
    TreeNode* t=a;
    queue<TreeNode*> q;
    q.push(a);
    while(!q.empty()){
        t=q.front();
        result[size++]=t->data;
        q.pop();
        if(t->leftN)q.push(t->leftN);
        if(t->rightN)q.push(t->rightN);
    }
}
int main(){
    cout<<"Input1"<<endl;
    string s;
    cin>>s;
    cout<<"Output1"<<endl;
    string a="1"+s;
    int length=a.size();
    Tree tree(a,length);
    tree.preOrder(tree.root);//前序遍历
    printNode(result,size);
    size=0;
    tree.inOrder(tree.root);//中序遍历
    printNode(result,size);
    size=0;
    tree.proOrder(tree.root);//后序遍历
    printNode(result,size);
    size=0;

    int nodeNum=s.size();
    int height1=tree.height(tree.root);
    cout<<nodeNum<<endl;
    cout<<height1<<endl;

    cout<<"Input2"<<endl;
    string s1;
    cin>>s1;
    string s2;
    cin>>s2;
    cout<<"Output2"<<endl;
    s1="1"+s1;
    s2="1"+s2;
    int l=s1.size()-1;
    TreeNode* t=mTree_pre_in(s1,s2,l);
    Tree tree2(t);
    tree2.proOrder(tree2.root);
    printNode(result,size);
    size=0;
    tree2.levelOrder(tree2.root);
    printNode(result,size);
    size=0;

    cout<<"End"<<endl;
}

💓 最后总结：

最后总结与感悟

本题要求完成的是数据结构中的树结构，包括树的生成、树的遍历、树高的求解等，树的生成包括给定层次遍历序列生成、给定中序和前序序列生成。

首先明确一个点，树的结构和递归脱不开关系，也就是说树中的操作很多时候都是靠递归方法去解决的，树的整个结构就是一个递归结构。

  1. 树层次遍历序列下的生成。给定一个层次遍历序列，我们是能够唯一生成一颗树的。从递归角度思考如何生成。生成的本质就是创建结点，由于实际上每个结点的值和位置在string层次遍历序列中我们都以及了解了，所以我们就可以思考一下创建整个过程的一个子过程：从外界创建一个根节点，然后生成并链接它的左右子结点。 接下来对刚刚生成的左右子节点做同样的操作，去链接生成他们的左右子节点。一次次递归，问题就得以解决。

总的来说就是1、整体过程是生成一棵树 2、子过程是对每一个结点生成并链接它的左右结点。如此，子过程不断重复整个树便可以形成

  1. 树的遍历分为前序中序和后序遍历。其核心思想就是在于什么时候输出结点，总共就三条语句。1、整体过程是遍历一整棵树。2、整体问题可以分解为访问左子树+访问右子树+对当前结点的访问。而遍历左子树、右子树的问题又能继续分为这三个子问题。而这三个问题的处理顺序就决定了我们遍历的顺序。
  2. 求解树高同样也是递归解决。1、整体问题是求解这棵树的树高。2、整体问题可以分解为求解其左右子树的树高，选取其中高的那个加1作为整体的树高。然后求解左右子树的树高问题又能做上面的分解。所以整体上又是一个递归重复的问题
  3. 树在给前中序序列下的生成。1、整体来看生成树的本质就是不停地生成新的结点。2、而生成结点同样可以分解为许多子问题。子问题的重复能够解决整体问题。3、子问题为：根据前序序列的第一个结点确定整棵树的根节点，同时生成这个根节点。并且根据中序序列，确定这棵树的左子树与右子树的元素。然后让根节点连接上生成的左子树与右子树。生成左右子树的方法和生成整体的相同，左右子树也看成一个独立树去生成。

注意的点：

  1. 在编写程序的过程中要注意一个点：递归是会不停重复函数，所以对于一些我们希望在递归过程中不要发生改变的量，我们应该定义并在函数外面进行赋值。例如结点个数size变量。一次printf操作，这些都是我们只希望在递归结束后执行一次的，所以不要放在递归内部
  2. 由于是树的操作，我们希望从下标为1开始。而我们读入string是从下标为0开始的，所以我们可以通过“1”+c这种方式，让string从下标1开始才有效。

创作不易，如果觉得内容不错，收藏一下呗，小猫求求了~

真的真的不行，就给个免费的赞吧~~ 

十二月的猫
关注
  • 11
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉树操作 C++实现
04-08
二叉树操作C++实现 二叉树操作C++实现 二叉树操作C++实现 二叉树操作C++实现 二叉树操作C++实现
二叉树-基于C++实现的二叉树操作.zip
04-26
二叉树 二叉树_基于C++实现的二叉树操作
【数据结构】层序生成二叉树
萧十一的技术小站
03-14 7289
层序创建二叉树所用的输入序列是按树的从上到下从左到右的顺序形成的，各层的空节点输入数值0。在构造二叉树的过程中，需要一个队列暂时存储各节点，其创建过程如下。 输入第一个数据： 若为0，表示此树为空，将空指针赋给根指针，树构造完毕。 若不为0，动态分配一个节点单元，并存入数据，同时将该节点放入队列。 若队列不为空，从队列拿出一个节点，并建立该节点的左右孩子： 从输入序列读入下一数据： 若读入数
二叉树的基本操作(C++实现)
热门推荐
qq_52109814的博客
08-09 2万+
基本概念 二叉树由结点的有限集合构成。 这个有限集合要么是空集，要么是一个根节点及两棵互不相交、分别称为这个跟的左子树和右子树的二叉树组成的集合。 二叉树的特点 每个结点最多有两棵子树，所以二叉树中不存在度大于2的结点。 左子树和右子树是有顺序的，次序不能随意颠倒。 及时树中某结点只有一颗子树，也要区分它是左子树还是右子树。 二叉树的五种基本形态 空二叉树 只有一个根节点 根节点只有左子树 根节点只有右子树 根节点既有左子树，又有右子树 相关概念 边（edge）：两个结点（node）的有序对（ord
C++实现二叉树
qq_45285738的博客
03-10 695
接下来，你将看到，输出先序、层序遍历结果等内容，如下：（注：中序后序，操作类似于前序遍历，没有实现）1.2 实现二叉树的访问 --- 先中后序访问、层序访问。1.3 计算树的深度、节点数、复制树。2.1 首先创建出一棵二叉树。1.1 实现二叉树的创建。
二叉树基本操作C++实现
Charming的博客
10-14 990
二叉树基本操作C++实现 基本操作预览: 先序遍历: element:1 element:2 element:3 中序遍历: element:2 element:1 element:3 二叉树的结点个数： 3 度为2的结点个数: 1 度为1的结点个数: 0 叶子结点个数: 2 二叉树的高度: 2 是不是完全二叉树(1-是;0-不是): 1 #include <stdio.h> #include <iostream> using namespace std; typedef st
C++实现二叉树及相关操作
qq_60012598的博客
04-09 530
二叉树的定义：是一种树形结构，特点是每个节点最多有两棵子树并且有左右之分二叉树的五种形态：空树，只有一个根，一个根和一个左子树，一个根和一个右子树，根和左右子树二叉树的特性：1.第i层最多有2的（i-1）次方个节点2.深度为h的二叉树最多有2的（h-1）次方个节点3.对一个完全二叉树进行顺序编号，对于编号为i的结点，i=1，为根；i%2=0说明 有该结点的父节点有一个左子树，i%2>0说明有左右子树。
平衡二叉树的C++实现
吉大秦少游
10-05 787
AVL需要在BST的基础上进行实现，因此首先需要将BST的常用操作封装在头文件<bstree.h>中。而BST又依赖于二叉树的实现，因此二叉树的实现封装在<bintree.h>中。如下： <bintree.h> // 二叉树的头文件 #ifndef bintree_h #define bintree_h #include <iostream> u...
树与二叉树的C++实现
m0_51539008的博客
03-06 645
包括树的定义、初始化、插入节点、层序与中序遍历、计算树的深度等操作的c++代码
C++实现树 - 02 二叉树
Newin2020的博客
05-04 5146
写在前面： 这一讲我们来看看二叉树的实现，还不清楚树的结构的小伙伴建议先看看上面一讲关于树的定义。 二叉树的定义 二叉树是每个结点最多有两个子树的树结构。也就是说二叉树不允许存在度大于2的树。它有五种最基本的形态：二叉树可以是空集。根可以有空的左自树或者右子树；或者左右子树都是空。其中只有左子树或者右子树的叫做斜树。 二叉树的主要性质 性质 结论 性质一 在二叉树的 i 层上至多有 2 ^ ( i - 1 ) 个结点（ i >= 1 ） 性质二 深度为 k 的二叉树至多有 2.
平衡二叉树详解及C++实现
c661280411470yb的博客
06-08 684
平衡二叉搜索树
二叉树的基本操作（C++实现）
锦恢的博客
11-21 2879
文章目录前言创建二叉树展示二叉树销毁二叉树判断是否为完全二叉树计算树的高度计算树的叶子数量计算树的宽度层次遍历前序遍历递归写法非递归写法中序遍历递归写法非递归写法后序遍历递归写法非递归写法输出根节点到所有叶子节点的路径(递归)输出根节点到所有叶子节点的路径(非递归)计算二叉树的公共祖先(lca)递归写法非递归写法验证 前言 二叉树可以说是树形数据结构中最基础的，且在多种领域都有应用（比如语法树，二值决策树），熟悉其各种操作是必须的。本文通过实现几个基本的函数来实现一个基本的二叉树： #include &lt
C++自实现二叉树的基本操作
11-03
1、本文详细描述了c++语言实现二叉树基本操作的方法。 2、通过详细示例，让读者更直观地阅读，更清晰的理解。 3、示例代码可直接复制，编译后可直接运行。 4、根据示例以及运行结果，让读者加强记忆及理解。
C++实现二叉树基本操作详解
08-28
主要为大家详细介绍了C++实现二叉树基本操作，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C++中的智能指针类别
最新发布
GOLOJO的博客
05-31 895
C++中的智能指针是用来管理动态内存的对象，避免我们手动管理内存时可能会带来的复杂性和错误。C++标准库提供了几种不同类型的智能指针，包括``、``和`- 优先使用``和``来创建智能指针，避免手动使用`new`，可以提高代码的安全性和性能。- 在使用``时要特别小心循环引用的问题。可以使用``来打破循环引用。- 确保智能指针的生命周期管理正确，避免悬空指针和内存泄漏。- 虽然智能指针极大地简化了内存管理，但也带来了额外的开销，如引用计数的维护。因此，在性能敏感的代码中，应慎重使用`
【最新区块链论文录用资讯】CCF A—INFOCOM 2024 共17篇
软件工程小施同学 的专栏
05-28 1467
详情：https://infocom2024.ieee-infocom.org/program/accepted-paper-list-main-conference。BR-DeFedRL：具有快速收敛和通信效率的拜占庭式鲁棒去中心化联邦强化学习。FileDES：一个安全、可扩展、简洁的基于区块链的去中心化加密存储网络。CRACKLE：具有次线性通信复杂性的基于扇区的快速 BFT 共识。通过可逆 GAN 实现高容量的基于区块链的通用隐写术框架。通过树图区块链的半异步去中心化联邦学习框架。
精通C++ STL（二）：string类的模拟实现
Russ_Leo的博客
05-27 848
string类各函数接口。
C语言 指针——指针变量的定义、初始化及解引用
hangweijie的博客
05-29 1224
目录指针内存如何编址？如何对变量进行寻址？用什么类型的变量来存放变量的地址?如何显示变量的地址?​编辑使用未初始化的指针会怎样？NULL是什么？如何访问指针变量指向的存储单元中的数据？指针变量的定义和初始化
【如何利用c++RAII技术实现自动加解锁】
逆风飞翔的博客
05-28 347
使用C++中的 RAII（资源获取即初始化）技术来实现自动加锁解锁
已知一颗树的结点序列以及每个结点的度，构造树的兄弟孩子链表，请给我这道题的C语言代码
05-26
以下是构造树的兄弟孩子链表的C语言代码： ```c #include <stdio.h> #include <stdlib.h> #define MAX_NODE_NUM 100 typedef struct Node { int val; struct Node* parent; struct Node* left_child; struct Node* right_sibling; } Node; Node nodes[MAX_NODE_NUM]; // 存储所有结点 int node_num; // 结点个数 Node* create_node(int val) { // 创建结点 Node* node = (Node*)malloc(sizeof(Node)); node->val = val; node->parent = NULL; node->left_child = NULL; node->right_sibling = NULL; return node; } void construct_tree(int* degrees, int n, int* vals) { // 构造树 node_num = n; for (int i = 0; i < n; i++) { nodes[i] = *create_node(vals[i]); } for (int i = 1; i < n; i++) { int d = degrees[i]; Node* parent = &nodes[d]; Node* child = &nodes[i]; child->parent = parent; child->right_sibling = parent->left_child; parent->left_child = child; } } void print_tree(Node* node, int depth) { // 打印树 for (int i = 0; i < depth; i++) { printf(" "); } printf("%d\n", node->val); Node* child = node->left_child; while (child != NULL) { print_tree(child, depth + 1); child = child->right_sibling; } } int main() { int degrees[] = {-1, 0, 1, 2, 2, 3}; // 每个结点的度 int vals[] = {0, 1, 2, 3, 4, 5}; // 结点序列 construct_tree(degrees, 6, vals); print_tree(&nodes[0], 0); return 0; } ``` 在该代码中，我们使用了一个`Node`结构体来表示树的结点，其中包含了结点的值、父结点指针、左孩子指针和右兄弟指针。`create_node`函数用于创建结点，`construct_tree`函数用于构造树，`print_tree`函数用于打印树。在`construct_tree`函数中，我们依次遍历每个结点，将其作为其父结点的孩子结点插入到树中。具体来说，我们先找到该结点的父结点，并将该结点的父结点指针和右兄弟指针设置为其父结点的左孩子和当前结点的右兄弟。在`print_tree`函数中，我们先打印该结点的值，然后遍历它的每个孩子结点，并递归打印它们。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

十二月的猫

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值