代码随想录 -- 二叉树(未完待续)

最新推荐文章于 2024-11-08 23:39:16 发布
最新推荐文章于 2024-11-08 23:39:16 发布
阅读量999 收藏 12
点赞数 28
分类专栏： C++ 数据结构与算法 文章标签： c++ linux 开发语言 算法 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bossddyy/article/details/136580217
版权

文章目录

因为lz考研复试可能优先回溯 动态规划 双指针，所以lz先进行这三样了！！！

二叉树递归遍历

前序遍历题目
后序遍历题目
中序遍历题目

#include<iostream>
#include <vector>

using namespace std;
struct TreeNode{
    int val;
    TreeNode*left;
    TreeNode*right;
    TreeNode():val(0),left(nullptr),right(nullptr){}
    TreeNode(int value):val(value),left(nullptr),right(nullptr){}
    TreeNode(int value,TreeNode*left,TreeNode*right):val(value),left(left),right(right){}
};
class BinaryTree{
public:
    // 先序遍历
    void preorder(TreeNode*root,vector<int>&result){
        if (!root)return;
        result.push_back(root->val);
        preorder(root->left,result);
        preorder(root->right,result);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int>result;
        preorder(root,result);
        return result;
    }

    // 后续遍历
    void postorder(TreeNode*root,vector<int>&result){
        if(!root)return;
        postorder(root->left,result);
        postorder(root->right,result);
        result.push_back(root->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int>result;
        postorder(root,result);
        return result;
    }

    //中序遍历
    void in(TreeNode*root,vector<int>&result){
        if(!root)return;
        in(root->left,result);
        result.push_back(root->val);
        in(root->right,result);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int>result;
        in(root,result);
        return result;
    }
};
int main(){
    TreeNode*t4 = new TreeNode(7);
    TreeNode*t3 = new TreeNode(8);
    TreeNode*t2 = new TreeNode(3,t3, nullptr);
    TreeNode*t1 = new TreeNode(1);
    TreeNode*t0 = new TreeNode(5,t2,t4);
    TreeNode*root = new TreeNode(10,t0,t1);
    BinaryTree bt;
    // 测试先序遍历
    auto v = bt.preorderTraversal(root);
    for (const auto &item: v) {
        cout<< item <<endl; 
    }
    delete root;
    delete t0;
    delete t1;
    delete t2;
    delete t3;
    delete t4;
    return 0;
}

二叉树迭代遍历

#include<iostream>
#include <vector>
#include<stack>
#include<algorithm>
using namespace std;
struct TreeNode{
    int val;
    TreeNode*left;
    TreeNode*right;
    TreeNode():val(0),left(nullptr),right(nullptr){}
    TreeNode(int value):val(value),left(nullptr),right(nullptr){}
    TreeNode(int value,TreeNode*left,TreeNode*right):val(value),left(left),right(right){}
};
class BinTree{
public:
    // 先序遍历
    /**
    * 栈是先入后出 先序遍历是 中左右
    * 入栈的时候先入右孩子 再入左孩子 这样出栈的时候可以先出左后出右
    * */
    vector<int> preorder(TreeNode*root){
        vector<int>result;//保存遍历之后的结果
        if (root== nullptr)return result;
        stack < TreeNode * > st; // 模拟递归的栈
        st.push(root);
        while (!st.empty()){
            auto r = st.top();
            st.pop();
            result.push_back(r->val);
            if (r->right)st.push(r->right);
            if (r->left)st.push(r->left);
        }
    return result;
    }
    // 后序遍历
    /**
    * 栈是先入后出 后序遍历是 左右中
    * 我们可以按照先序的 不过入栈的时候先入左孩子 再入右孩子
     * 这样的出来的是后序遍历的翻转
     */
    vector<int>postorder(TreeNode*root){
        stack<TreeNode*>st;
        vector<int>result;
        if (root== nullptr)return result;
        st.push(root);
        while (!st.empty()){
            auto r = st.top();
            st.pop();
            result.push_back(r->val);
            if (r->left)st.push(r->left);
            if (r->right)st.push(r->right);
        }
        reverse(result.begin(),result.end());
        return result;
    }

    //中序遍历
    vector<int> inorder(TreeNode*root){
        vector<int>result;
        if (root== nullptr)return result;
        TreeNode*cur = root;
        stack<TreeNode*>st;
        while (cur||!st.empty()){
            if (cur){// 指针来访问节点，访问到最底层
                st.push(cur);// 将访问的节点放进栈
                cur=cur->left;
            }else{
                cur = st.top();// 从栈里弹出的数据，就是要处理的数据
                st.pop();
                result.push_back(cur->val);//中
                cur=cur->right;//右
            }
        }
        return result;
    }
};
int main(){
    TreeNode*t4 = new TreeNode(7);
    TreeNode*t3 = new TreeNode(8);
    TreeNode*t2 = new TreeNode(3,t3, nullptr);
    TreeNode*t1 = new TreeNode(1);
    TreeNode*t0 = new TreeNode(5,t2,t4);
    TreeNode*root = new TreeNode(10,t0,t1);
    BinTree bt;
    auto v = bt.inorder(root);
    for (const auto &item: v) {
        cout<< item <<endl;
    }
    delete root;
    delete t0;
    delete t1;
    delete t2;
    delete t3;
    delete t4;
    return 0;
}

二叉统一的迭代遍历法

代码随想录网站

二叉树的层序遍历合集

二叉树层序遍历I

题目链接

描述

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
在这里插入图片描述

题解

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>>result;
        if(root==nullptr)return result;
        queue<TreeNode*>q;
        q.push(root);
        while (!q.empty()){
            vector<int>vec;
            int size = q.size();
            for (int i = 0; i < size; ++i) {
                TreeNode* cur = q.front();
                vec.push_back(cur->val);
                q.pop();
                if (cur->left)q.push(cur->left);
                if (cur->right)q.push(cur->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

二叉树层序遍历II

题目链接

描述

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
在这里插入图片描述

题解

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>>result;
        if(root==nullptr)return result;
        queue<TreeNode*>q;
        q.push(root);
        while (!q.empty()){
            vector<int>vec;
            int size = q.size();
            for (int i = 0; i < size; ++i) {
                TreeNode* cur = q.front();
                vec.push_back(cur->val);
                q.pop();
                if (cur->left)q.push(cur->left);
                if (cur->right)q.push(cur->right);
            }
            result.push_back(vec);
        }
        reverse(result.begin(),result.end());
        return result;
    }
};

二叉树的右视图

题目链接

描述

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

在这里插入图片描述

题解

层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int>res;
        if (root == nullptr)return res;
        queue<TreeNode*>q;
        q.push(root);
        while (!q.empty()){
            int len = q.size();
            for (int i = 0; i < len; ++i) {
                auto t = q.front();
                q.pop();
                if(i==len-1)res.push_back(t->val);
                if (t->left)q.push(t->left);
                if (t->right)q.push(t->right);
            }
        }
        return res;
    }
};

二叉树的层平均值

题目链接

描述

给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。
在这里插入图片描述

题解

本题就是层序遍历的时候把一层求个总和在取一个均值。

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double>res;
        if (root== nullptr)return res;
        queue<TreeNode*>q;
        q.push(root);
        while (!q.empty()){
            const int len = q.size();
            double count=0;
            for (int i = 0; i < len; ++i) {
                auto t = q.front();
                q.pop();
                count+=t->val;
                if (t->left)q.push(t->left);
                if (t->right)q.push(t->right);
            }
            res.push_back(count/len);
        }
        return res;
    }
};

N叉树的层序遍历

题目链接

描述

给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。
在这里插入图片描述

题解

类似于二叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>>res;
        if (root== nullptr)return res;
        queue<Node*>q;
        q.push(root);
        while (!q.empty()){
            vector<int>tmpRes;
            int len = q.size();
            for (int i = 0; i < len; ++i) {
                auto t=q.front();
                q.pop();
                tmpRes.push_back(t->val);
                for (int j = 0; j < t->children.size(); ++j)
                    q.push(t->children[j]);
            }
            res.push_back(tmpRes);
        }
        return res;
    }
};

在每个树行中找最大值

题目链接

描述

您需要在二叉树的每一行中找到最大的值。

在这里插入图片描述

题解

层序遍历，取每一层的最大值

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int>res;
        if (root== nullptr)return res;
        queue<TreeNode*>q;
        q.push(root);
        while (!q.empty()){
            int len = q.size();
            int maxNum=-2147483648;
            for (int i = 0; i < len; ++i) {
                auto t=q.front();
                q.pop();
                maxNum=(t->val>maxNum)?t->val:maxNum;
                if (t->left)q.push(t->left);
                if (t->right)q.push(t->right);
            }
            res.push_back(maxNum);
        }
        return res;
    }
};

填充每个节点的下一个右侧节点指针

题目链接

描述

给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。
在这里插入图片描述

题解

依旧是层序遍历，不过保存上次层序遍历的节点

class Solution {
public:
    Node* connect(Node* root) {
        if (root== nullptr)return root;
        queue<Node*>q;
        q.push(root);
        while (!q.empty()){
            int len = q.size();
            Node*tmp= nullptr;
            for (int i = 0; i < len; ++i) {
                Node*t=q.front();
                q.pop();
                if (tmp)tmp->next=t;
                if (i==len-1)t->next= nullptr;
                else{
                    tmp=t;
                }
                if (t->left)q.push(t->left);
                if (t->right)q.push(t->right);
            }
        }
        return root;
    }
};

填充每个节点的下一个右侧节点指针II

题目链接

描述

给定一个二叉树：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。

初始状态下，所有 next 指针都被设置为 NULL 。

题解

一样的逻辑

class Solution {
public:
    Node* connect(Node* root) {
        if (root== nullptr)return root;
        queue<Node*>q;
        q.push(root);
        while (!q.empty()){
            int len = q.size();
            Node*tmp= nullptr;
            for (int i = 0; i < len; ++i) {
                Node*t=q.front();
                q.pop();
                if (tmp)tmp->next=t;
                if (i==len-1)t->next= nullptr;
                else{
                    tmp=t;
                }
                if (t->left)q.push(t->left);
                if (t->right)q.push(t->right);
            }
        }
        return root;
    }
};

二叉树最大深度

题目链接

描述

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：

给定二叉树 [3,9,20,null,null,15,7]，
在这里插入图片描述

题解：层序遍历

class Solution {
public:

    int maxDepth(TreeNode*root){
        if (root== nullptr)return 0;
        queue<TreeNode*>q;
        q.push(root);
        int depth=0;
        while (!q.empty()){
            int len = q.size();
            for (int i = 0; i < len; ++i) {
                auto node=q.front();
                q.pop();
                if (node->left)q.push(node->left);
                if (node->right)q.push(node->right);
            }
            ++depth;
        }
        return depth;
    }
};

题解：递归（深度优先搜索）

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (!root)return 0;
        int leftHigh = maxDepth(root->left);
        int rightHigh = maxDepth(root->right);
        return max(leftHigh,rightHigh)+1;
    }
};

二叉树的最小深度

题目链接

描述

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

题解：层序遍历

只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点

class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root== nullptr)return 0;
        queue<TreeNode*>q;
        int depth=0;
        q.push(root);
        while (!q.empty()){
            int len =q.size();
            ++depth;
            for (int i = 0; i < len; ++i) {
                TreeNode*node=q.front();
                q.pop();
                if (!node->left&&!node->right)return depth; 
                if (node->left)q.push(node->left);
                if (node->right)q.push(node->right);
            }
        }
        return depth;
    }   
};

题解：递归（深度优先）

class Solution {
public:
    int minDepth(TreeNode *root) {
        if (root == nullptr) {
            return 0;
        }

        if (root->left == nullptr && root->right == nullptr) {
            return 1;
        }

        int min_depth = INT_MAX;
        if (root->left != nullptr) {
            min_depth = min(minDepth(root->left), min_depth);
        }
        if (root->right != nullptr) {
            min_depth = min(minDepth(root->right), min_depth);
        }

        return min_depth + 1;
    }
};

翻转二叉树

题目链接

描述

翻转一棵二叉树。
在这里插入图片描述

题解：递归法

本题使用递归法 很是方便，我们定义一个实现翻转的函数，但root有左/右孩子的时候再翻转其左右孩子，直至root的左右孩子为空

class Solution {
public:
    void invert(TreeNode*root){
        if (root== nullptr)return;
        swap(root->left,root->right);
        invert(root->left);
        invert(root->right);
    }
    TreeNode* invertTree(TreeNode* root) {
        invert(root);
        return root;
    }
};

题解：迭代法

前序遍历和后续遍历途中进行翻转，下面的代码使用的是前序遍历

class Solution {
public:
    TreeNode*invertTree(TreeNode*root){
        if (root== nullptr)return root;
        stack<TreeNode*>st;
        st.push(root);
        while (!st.empty()){
            auto node=st.top();
            st.pop();
            swap(node->left,node->right);
            if (node->right)st.push(node->right);
            if (node->left)st.push(node->left);
        }
        return root;
    }
};

题解：层序遍历

class Solution {
public:
    TreeNode*invertTree(TreeNode*root){
          if (root== nullptr)return root;
        queue<TreeNode*>q;
        q.push(root);
        while (!q.empty()){
            auto node=q.front();
            q.pop();
            swap(node->left,node->right);
            if (node->left)q.push(node->left);
            if (node->right)q.push(node->right);
        }
        return root;
    }
};

对称二叉树

题目链接

描述

给定一个二叉树，检查它是否是镜像对称的。

在这里插入图片描述

题解：递归

class Solution {
public:
    bool compare(TreeNode*left,TreeNode*right){
        if (left&&!right)return false;
        else if(!left&&right)return false;
        else if (!left&&!right)return true;
        else if(left->val!=right->val)return false;

        bool leftFlag = compare(left->left,right->right);
        bool rightFlag = compare(left->right,right->left);

        return leftFlag&&rightFlag;
    }
    bool isSymmetric(TreeNode* root) {
        if (!root)return true;
        return compare(root->left,root->right);
    }
};

题解：迭代法

class Solution {
public:
    bool isSymmetric(TreeNode*root) {
        if (!root)return true;
        queue<TreeNode*>q;
        q.push(root->left);
        q.push(root->right);
        while (!q.empty()){
            auto n1=q.front();q.pop();
            auto n2=q.front();q.pop();
            if (!n1&&!n2)continue;
            if (n1&&!n2||!n1&&n2||n1->val!=n2->val)return false;
            q.push(n1->left);
            q.push(n2->right);
            q.push(n1->right);
            q.push(n2->left);
        }
        return true;
    }
};
yb0os1
关注
专栏目录
leetcode刷题笔记8-二叉树（未完待续）
infinite2020的博客
04-03 173
因为我们在刷leetcode的时候，刷题模式是核心代码模式，节点的定义默认都定义好了，真到面试的时候，需要自己写节点定义的时候，有时候会一脸懵逼刚刚我们说过了二叉树有两种存储方式顺序存储，和链式存储，顺序存储就是用数组来存，这个定义没啥可说的，我们来看看链式存储的二叉树节点的定义方式。int val;//存储对应节点的数值 TreeNode * left;//定义左指针，指向左孩子 TreeNode * right;
代码随想录总结 | 慢慢总结,想起啥就先写上
he979731102的博客
02-23 397
算法总结
Leetcode刷题注意点：二叉树
Ajdidfj的博客
01-29 343
基于代码随想录的Leetcode刷题注意点
代码随想录总结
he979731102的博客
03-15 385
算法和数据结构总结
我在代码随想录-写代码Day16之二叉树
01-24
二叉树遍历
代码随想录-最强八股文（第五版）
03-01
《代码随想录-最强八股文（第五版）》是一部综合性的编程知识合集，旨在帮助程序员，尤其是面试者，提升在前端、后端以及Java和Go等领域的技术素养。这一版本的内容涵盖了大量的面试常见问题，是程序员们准备技术...
代码随想录：全面解析二叉树理论与应用实例
09-17
内容概要：本文来自《代码随想录》，详尽探讨了有关二叉树的各类知识。包含了二叉树的种类（满二叉树、完全二叉树）、平衡树、遍历方式及其实现代码，涵盖了深度与广度两种不同的搜索策略以及非递归的方法。本文适用...
【代码随想录】二叉树
qq_44378854的博客
05-23 303
【代码】【代码随想录】二叉树。
代码随想录-035期-算法训练营【博客笔记汇总表】
upward
04-10 651
代码随想录-035期-算法训练营【博客笔记汇总表】
代码随想录-二叉树
weixin_45678185的博客
08-29 72
如果在递归过程中出现左子树的高度与右子树高度之差大于1的话，就返回-1，否则的话就返回1+max(左子树高度，右子树高度)。先求左子树的左叶子之和，再求右子树的左叶子之和，再加上通过根结点判断的左叶子的值，就可得到最终的值。左叶子的判断逻辑为：结点A的左孩子结点B不为空，且结点B的左孩子和右孩子都为空，则结点B为左叶子结点。左右孩子都不为空，把左孩子移到以右孩子为根结点的子树的最左叶子结点的下面。递归函数传入两棵树的根节点，递归终止的条件就是如果t1为空，就返回t2，如果t2为空，就返回t1。
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
《代码随想录》是一本深受程序员喜爱的编程学习资料，尤其在算法领域，它提供了丰富的实例和深入的解析，帮助读者理解并掌握动态规划、回溯、递归、二叉树以及贪心等核心算法。这些算法是解决复杂计算问题的基础工具...
编译器、IDE对C/C++新标准的支持
编程语言技巧经验分享
11-08 655
很遗憾的是，微软VC++对C99的支持直到VS2015才基本完全支持，在VS2012之前，仅仅支持C89. 也正是2015年之前，这么多人骂微软并纷纷转移到其它C语言编译器的原因。VS2019开始才正式宣布支持C11/C17.对于C++标准，VS2013开始支持C++11，VS2017支持C++17, VS2019支持C++20, 显然，微软更偏爱C++.
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 74
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
C++builder中的人工智能（15）：C++高斯误差线性单元（GELU）
最新发布
caridle的专栏
11-08 361
激活函数（phi()），也称为转移函数或阈值函数，它根据净输入函数的给定值（sum）确定激活值（a = phi(sum)）。在这里，sum是它们权重中的信号之和，激活函数是这个和的新值，具有给定的函数或条件。换句话说，激活函数是将所有加权信号的和转换为该信号的新激活值的方法。有不同类型的激活函数，通常使用的是线性（恒等）、双极性和逻辑（sigmoid）函数。在C++（以及大多数编程语言）中，你可以创建自己的激活函数。注意，sum是净输入函数的结果，它计算所有加权信号的和。我们将使用这些作为输入函数的结果。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 17
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 402
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
算法|牛客网华为机试31-40C++
奇树谦的博客
11-04 724
计算第5次落地后球经过的距离，除了第一次只经过一次，所以距离最后在减去初始长度，高度每次减去一半。for循环遍历一次，从后往前，如果是字符组成单词等遇到空格或者非字母输出。直接用sort函数就是按着ASCII码从小到大排序的。找每行每列的相加差1的数学规律，再每行输出。
C++ 编程基础（4）函数 | 4.1、函数概述
个人技术博客
11-04 228
在C++中，函数通过函数定义来创建，其语法包括返回类型、函数名、参数列表（可选）和函数体。函数指针是指向函数的指针变量。因此函数指针本质上是一个指针变量，只不过该指针变量指向函数。C/C++中，每一个函数都有一个入口地址，函数指针就指向函数的入口地址，可以通过函数指针来调用函数。return 0;// pfnFunc保存的就是func函数地址，pfnFunc与func值是一样的return 0;输出结果0040135000401350。
c++ 分治算法
www_dong的博客
11-08 653
分治算法是一种重要的算法设计范式，其核心思想是将一个复杂的问题分解为多个规模较小的相同问题，逐步解决这些较小的问题，最后将这些问题的解合并成原问题的解。
C语言 流程控制语句
2201_75297369的博客
11-05 484
时间：2024.11.5。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值