我在代码随想录|写代码Day16之二叉树-二叉树的层序遍历, 二叉树的层次遍历 II, 二叉树的右视图,N叉树的层序遍历,在每个树行中找最大值,填充每个节点的下一个右侧节点指针,二叉树的最大/小深度

已于 2024-01-24 19:01:11 修改
阅读量894 收藏 24
点赞数 20
分类专栏： C/C++语言刷题 数据结构与算法 文章标签： c++ 笔记 数据结构 算法
于 2024-01-24 18:59:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_79299383/article/details/135815403
版权

学习目标：

博主介绍: 27dCnc
专题 : 数据结构帮助小白快速入门
👍👍👍👍👍👍👍👍👍👍👍👍
☆*: .｡. o(≧▽≦)o .｡.:*☆

主题: 二叉树

今日份打卡
在这里插入图片描述

  • 代码随想录-二叉树

文章目录

学习内容：

  1. 二叉树的层序遍历
  2. 二叉树的层次遍历 II
  3. 二叉树的右视图
  4. 二叉树的层平均值
  5. N叉树的层序遍历
  6. 在每个树行中找最大值
  7. 填充每个节点的下一个右侧节点指针
  8. 填充每个节点的下一个右侧节点指针II
  9. 二叉树的最大深度
  10. 二叉树的最小深度

内容讲解:

二叉树的层序遍历模版题

题目
二叉树的层序遍历
层序遍历
图解
二叉树层序遍历图解
思路解析:

俩个重要容器

  1. queue<TreeNode*>que; 队列
  2. `vector<vector> 二维数组

队列用于储存每一层的结点
二维数组用于储存每已成都结果

终止条件是队列为空,只要根结点不为空,就将根结点放入队列,进入循环后,队列的长度为每一层遍历的大小,然后将父节点的孩子结点放入队列,然后将父节点出队列,将父节点的值储存在新建立的vector<int>中然后不断循环每一层循环后将vwctor<int>放入vector<vector<int>>中

层序遍历顺序

  1. 创建队列储存每一层结果
  2. 创建二维数组用于储存每一层的结果
  3. 进入循环去遍历每一层结果,终止条件是队列为空
  4. 用 size 储存二叉树中每一层的数组
  5. 应 vector<int>储存每一层数组的值
  6. 将根结点的左右孩子放入队列中

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> ans;
        if(root != nullptr) que.push(root);
        while(!que.empty()) {
            int size = que.size();
            vector<int>vec;
            for(int i = 0;i < size;i++) {
                TreeNode*node = que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            ans.push_back(vec);
        }
        return ans;
    }
};

二叉树的层序遍历 II

题目
二叉树的层序遍历 II
代码

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != nullptr) que.push(root);
        vector<vector<int>> ans;
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            for(int i=0;i<size;i++){
                TreeNode*node = que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            ans.push_back(vec);//记录每一层
        }
        reverse(ans.begin(),ans.end());
        return ans;
    }
};

reverse()用于反转层序遍历结果可以达到从下到上的遍历效果

199.二叉树的右视图

题目
二叉树的右视图
思路

可以层序遍历然后取层序遍历的最右边的数据,然后将数据存储到vector数组中返回
层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了,其中result数组即vector数组。

代码

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
         vector<int>ans;
         queue<TreeNode*>que;
         if(root != nullptr) que.push(root);
         while(!que.empty()) {
             int size = que.size();
             for(int i=0;i<size;i++){
                TreeNode*node = que.front();//取栈顶元素即上一层元素
                que.pop();//弹出元素准备放入该弹出元素的孩子结点
                if(i==size-1) ans.push_back(node->val);//没一层的最右的结点
                if(node->left) que.push(node->left);遍历树
                if(node->right) que.push(node->right);
             }
         }
         return ans;
    }
};

637. 二叉树的层平均值

题目
二叉树的层最大值

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

代码

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double>ans;
        queue<TreeNode*>que;
        if(root != nullptr) que.push(root);
        while(!que.empty()) {
            long long sum = 0;
            int size = que.size();
            vector<int>vec;
            for(int i=0;i<size;i++) {
                TreeNode*node = que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            for(int i=0;i<size;i++) {
                sum+=vec[i];
            }
            ans.push_back(1.0*sum/size);
        }
        return ans;
    }
};

层序遍历模版 + 求数组平均值 + 将数组传入改为将平均值传入

429. N 叉树的层序遍历

题目

N 叉树的层序遍历

层序遍历进阶

N叉树与二叉树的不同

  • N叉树相较于二叉树孩子数量不同而且不国定
  • 结构并不平衡孩子结点的定义规则不同

N叉树定义

// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};

二叉树定义

   Definition for a binary tree node.
   struct TreeNode {
       int val;
       TreeNode *left;
       TreeNode *right;
       TreeNode() : val(0), left(nullptr), right(nullptr) {}
       TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
       TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 };

解决多孩子问题可以用遍历数组的方式

多孩子遍历

因为孩子是通过vector<Node*> children;储存的所以可以使用 node->children.size()统计数组长度,通过 if(node -> children[i]) que.push(node->children[i]);去遍历树的孩子。

层序遍历

代码

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*>que;
        if(root != nullptr) que.push(root); 
        vector<vector<int>> ans;
        while(!que.empty()) {
            int size = que.size();
            vector<int>vec;
            for(int i=0;i < size;i++) {
                Node*node = que.front();
                que.pop();
                vec.push_back(node->val);
                for(int i =0;i< node->children.size() ; i++) {
                    if(node -> children[i]) que.push(node->children[i]);
                }
            }
            ans.push_back(vec);
        }
        return ans;
    }
};

515.在每个树行中找最大值

题目

在每个树行中找最大值

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

代码

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != nullptr) que.push(root);
        vector<int> ans;
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            for(int i=0;i<size;i++){
                TreeNode*node = que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            sort(vec.begin(),vec.end());
            ans.push_back(vec[size-1]);//记录每一层最大值
        }
        return ans;
    }
};

其他版本

Python

class Solution:
    def largestValues(self, root: TreeNode) -> List[int]:
        if not root:
            return []

        result = []
        queue = collections.deque([root])

        while queue:
            level_size = len(queue)
            max_val = float('-inf')

            for _ in range(level_size):
                node = queue.popleft()
                max_val = max(max_val, node.val)

                if node.left:
                    queue.append(node.left)

                if node.right:
                    queue.append(node.right)

            result.append(max_val)

        return result

Java

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        if(root == null){
            return Collections.emptyList();
        }
        List<Integer> result = new ArrayList();
        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int max = Integer.MIN_VALUE;
            for(int i = queue.size(); i > 0; i--){
               TreeNode node = queue.poll();
               max = Math.max(max, node.val);
               if(node.left != null) queue.offer(node.left);
               if(node.right != null) queue.offer(node.right);
            }
            result.add(max);
        }
        return result;
    }
}

Go

/**
515. 在每个树行中找最大值
 */
func largestValues(root *TreeNode) []int {
    if root == nil {
        //防止为空
        return nil
    }
    queue := list.New()
    queue.PushBack(root)
    ans := make([]int, 0)
    temp := math.MinInt64
    // 层序遍历
    for queue.Len() > 0 {
        //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
        length := queue.Len()
        for i := 0; i < length; i++ {
            node := queue.Remove(queue.Front()).(*TreeNode)//出队列
            // 比较当前层中的最大值和新遍历的元素大小，取两者中大值
            temp = max(temp, node.Val)
            if node.Left != nil {
                queue.PushBack(node.Left)
            }
            if node.Right != nil {
                queue.PushBack(node.Right)
            }
        }
        ans = append(ans, temp)
        temp = math.MinInt64
    }
    return ans
}

func max(x, y int) int {
    if x > y {
        return x
    }
    return y
}

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

题目

填充每个节点的下一个右侧节点指针
样例图解
1
思路
本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            // vector<int> vec;
            Node* nodePre;
            Node* node;
            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodePre = que.front(); // 取出一层的头结点
                    que.pop();
                    node = nodePre;
                } else {
                    node = que.front();
                    que.pop();
                    nodePre->next = node; // 本层前一个节点next指向本节点
                    nodePre = nodePre->next;
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            nodePre->next = NULL; // 本层最后一个节点指向NULL
        }
        return root;

    }
};

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

题目

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

思路
这道题目说是二叉树，但116题目说是完整二叉树，其实没有任何差别，一样的代码一样的逻辑一样的味道

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            Node* nodePre;
            Node* node;
            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodePre = que.front(); // 取出一层的头结点
                    que.pop();
                    node = nodePre;
                } else {
                    node = que.front();
                    que.pop();
                    nodePre->next = node; // 本层前一个节点next指向本节点
                    nodePre = nodePre->next;
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            nodePre->next = NULL; // 本层最后一个节点指向NULL
        }
        return root;
    }
};

104. 二叉树的最大深度

题目

二叉树的最大深度

思路
使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。
在二叉树中，一层一层的来遍历二叉树，记录一下遍历的层数就是二叉树的深度

深度与高度

递归法

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

迭代法

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            depth++; // 记录深度
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return depth;
    }
};

回溯法

class Solution {
public:
    int result;
    void getDepth(TreeNode* node,int depth) {
        result = depth > result ? depth : result;//中

        if (node->left == nullptr && node->right == nullptr) return ;

        if(node->left) { //左
            depth++;//深度+1
            getDepth(node->left,depth);
            depth--;//回溯深度-1 ,变向状态转换
        }
        if (node->right) {
            depth++;//深度+1
            getDepth(node->right,depth);
            depth--;//回溯深度-1 ,变向状态转换
        }
        return ;
    }
     int maxDepth(TreeNode* root) {
       result=0;
       if (root == nullptr) return result;
       getDepth(root,1);
       return result;
    }
};

111.二叉树的最小深度

题目

二叉树最小深度

思路

相对于 104.二叉树的最大深度 ，本题还也可以使用层序遍历的方式来解决，思路是一样的。

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

递归法

class Solution {
public:
    int minDepth(TreeNode* root) {
              if (root == nullptr) {
            return 0;
        }
        int depth_left = minDepth(root->left);
        int depth_right = minDepth(root->right);
        if(root->left == nullptr || root->right == nullptr){
            return 1 + max(depth_left, depth_right);
        }else{
            return 1 + min(depth_left, depth_right);
        }
    }
};

六花

学习时间：

  • 周一至周五晚上 7 点—晚上9点
  • 周六上午 9 点-上午 11 点
  • 周日下午 3 点-下午 6 点

学习产出：

  • 技术笔记 2 遍
  • CSDN 技术博客 3 篇
  • 习的 vlog 视频 1 个

🔥如果此文对你有帮助的话，欢迎💗关注、👍点赞、⭐收藏、✍️评论，支持一下博主~

EvLast
关注
  • 20
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
二叉树三种遍历（动态图+代码深入理解）
流楚丶格念的博客
04-29 3万+
文章目录一、图示理解（图片是一位前辈所留，在此感谢）1、先序遍历2、中序遍历3、后序遍历4、层序遍历二、深入理解三种遍历让我们来理解一下绕着外围跑一整圈的真正含义是：遍历所有结点时，都先往左孩子走，再往右孩子走。下面做一个实例吧三、代码实现加以理解以下是C语言全部代码实现下面是同样的例子用c++实现，大家可以参考一下 一、图示理解（图片是一位前辈所留，在此感谢） 1、先序遍历 先序遍历可以想象成，...
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
正弦定理的博客
12-09 35万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
【数据结构】--- 二叉树的递归遍历和非递归遍历【C语言实现】
mike_jun的博客
07-17 3万+
目录 1. 创建一颗二叉树 2.递归前序遍历二叉树 3.递归中序遍历二叉树 4.递归后序遍历二叉树 5. 测试递归打印二叉树代码 6. 非-递归前序遍历二叉树 7.非-递归实现中序遍历二叉树 8.非 - 递归实现后序遍历【较为复杂的方法】 9.非 - 递归实现后序遍历【简单的方法】 10. 二叉树的层次遍历 11. 最后：附全部代码： 对于二叉树的非递归 深度优先遍历，使用的都是栈 对于二叉树的层次遍历，使用的是队列 1. 创建一颗二叉树 依据前序遍...
二叉树----层序遍历
qq_51622961的博客
05-02 1882
1.层序遍历 层序遍历:层序遍历即逐层按顺序遍历二叉树的各个节点,故层序遍历又叫广度优先遍历. 如图:广度优先遍历即按ABCDEFGH的顺序遍历 2.解题思路 1.这里我们利用队列先进先出的结构特点,当我们在队列中弹出一个树的节点时,我们便把树的左孩子和右孩子入到队列之中.(如果父节点的左右孩子为空时,我们便可不对其孩子进行入队列操作) 2.根据上面描述,我们可以用一个while循环解决入队列与出队列操作,结束条件便是判断队列是否为空. 3.代码实现 我们用C语言实现时,我们得自己写一个队列的结构,该
数据结构与算法----详解二叉树的遍历(迭代、递归)
小鱼干儿的博客
11-03 3244
数据结构与算法----二叉树的遍历，文章使用递归和迭代两种方法详细的解释的二叉树的遍历的四种方式，前序遍历，中序遍历，后序遍历，层次遍历，不仅有常见的递归解题，还有使用迭代方式实现，迭代的部分每一步的操作流程都标注了出来，帮助大家理解。
二叉树前序遍历、中序遍历、后序遍历、层序遍历的直观理解
热门推荐
白夜行的狼
05-23 37万+
0. 写在最前面 希望大家收藏： 本文持续更新地址：https://haoqchen.site/2018/05/23/go-through-binary-tree/     复习到二叉树，看到网上诸多博客文章各种绕，记得头晕。个人觉得数学、算法这些东西都是可以更直观简洁地表示，然后被记住的，并不需要靠死记硬背。 本文的程序基本来源于《大话数据结构》，个人感觉是一本非常好的书，推荐去看。 ...
二叉树的层序遍历（两种方法实现）
askunix
06-24 13万+
两种方法实现二叉树的层序遍历 1、说明 二叉树的层序遍历是面试经常会被考察的知识点，甚至要求当场写出实现过程。 层序遍历所要解决的问题很好理解，就是按二叉树从上到下，从左到右依次打印每个节点中存储的数据。如下图： 先序遍历：A → B → D → C 中序遍历：B → D → A → C 后续遍历：D → B → C → A 层序遍历：A → B → C →...
二叉树的之字形层序遍历
Oneby的博客
09-05 2999
二叉树的之字形层序遍历 1、参考资料 https://www.nowcoder.com/practice/47e1687126fa461e8a3aff8632aa5559 2、题目要求 题目描述 给定一个二叉树，返回该二叉树的之字形层序遍历，（第一层从左向右，下一层从右向左，一直这样交替） 例如：给定的二叉树是 {3,9,20,#,#,15,7} 该二叉树之字形层序遍历的结果是 [ [3], [20,9], [15,7] ] 示例 输入 {1,#,2} 输出 [[1],[2]] 3、代码思路
数据结构-二叉树（包含二叉树的层次建树、前中后序遍历、层次遍历解析及代码）
mayu_xuan的博客
12-11 2335
树是n(n>=0)个结点的有限集。当n=0时，称为空树。在任意一棵非空树中应满足：1）有且仅有一个特定的结点称为根的结点。2）当n>1时，其余结点可以分为m(m>0)个互不相交的有限集T1,T2,......,Tm,其中每个集合本身又是一棵树，并且称为根的子树。二叉树是另一种树形结构。其特点是每个结点至多只有两棵子树（即二叉树中不存在度大于二的结点），并且二叉树的子树有左右之分，其次序不能任意颠倒。与树相似，二叉树也以递归的形式定义。
猿创征文 | 详解二叉树之遍历及其应用（动图遍历演示）
forever的博客
09-01 2481
二叉树的遍历和相关应用的介绍和学习到这里就结束啦~目前简单的一些数据结构基本就拿C实现介绍差不多啦，后面就会进入排序的学习哈。但是在这里，希望大家能够将前面的树的基础概念以及之前的线性结构知识进行回顾复习，使整个纯C数据结构学习是连贯的，这样更加利于我们的学习和理解以及继续拓展。。代码不负有心人，98加满，向前冲啊🐬🎉🎉🎉以上代码均可运行，所用编译环境为 vs2019 ,运行时注意加上编译头文件#define _CRT_SECURE_NO_WARNINGS 1。......
我在代码随想录-写代码Day16之二叉树
01-24
二叉树遍历
Objective-C实现二叉树遍历算法（源代码）
04-30
本文展示了如何在Objective-C中实现一个简单的二叉树算法。首先，定义了一个二叉树节点的类BinaryTreeNode，用于存储数据和指向左右子节点的指针。接着，定义了一个二叉树类BinaryTree，该类包含一个根节点指针，并...
js代码-二叉树的层序遍历
07-16
js代码-二叉树的层序遍历
二叉树层序遍历-实现代码-队列
12-02
/* 设栈元素为二叉树的指针类型 */ typedef struct { QElemType *base; int front; /* 头指针,若队列不空,指向队列头元素 */ int rear; /* 尾指针,若队列不空,指向队列尾元素的下一个位置 */ } SqQueue; ...
二叉树的创建与遍历C语言实现代码.zip
05-27
二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言...
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 980
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 133
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 657
LeetCode 算法：轮转数组c++
手搓顺序表（C语言）
最新发布
m0_62646213的博客
06-12 1093
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例。该代码使用了递归法的前序遍历，对于每一个节点，交换其左右子节点，然后递归地对其左右子树进行翻转。 引用中给出了一个实现二叉树的层序遍历的代码示例。该代码使用了BFS的思想，借助队列来实现层序遍历。每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列，同时将当前层的节点值添加到结果列表中。 综上所述，参考这些引用，可以通过BFS来实现二叉树的层序遍历，并通过递归法或迭代法来翻转二叉树。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值