随想录Day15-- 层序遍历, 226.翻转二叉树 , 101. 对称二叉树

最新推荐文章于 2024-05-23 03:03:58 发布
最新推荐文章于 2024-05-23 03:03:58 发布
阅读量52 收藏
点赞数 1
文章标签： 算法 数据结构 java leetcode Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46516575/article/details/129285858
版权

层序遍历有10题，每道题的思路是一样的，关键在于怎么判断这一层是否结束。这里借助

队列和辅助遍历size。队列用来存放下一层的元素，size来表示下一层元素的个数，当size=0时表示这一层的元素已经全部弹出（如果不设置一个辅助变量size，队列中会有当层元素和下层元素混合的情况，无法判断是否已经把当层元素遍历完）

第一次接触层序遍历时，可以看卡哥的视频，理解思路。后面就可以不用了。

102. 二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]

输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]

输出：[[1]]

示例 3：

输入：root = []

输出：[]

提示：

  • 树中节点数目在范围 [0, 2000] 内

  • -1000 <= Node.val <= 1000

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> list2 = new ArrayList<List<Integer>>();
        int size = 0;
        Queue<TreeNode> queue = new LinkedList<>();
        if(root == null){
            return list2;
        }
        queue.offer(root);
        size = queue.size(); //这个size用来存贮当层的元素数量
        while(!queue.isEmpty()){//队列不为空，那就还没遍历完
            List<Integer> list = new ArrayList<>();
            for(int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                list.add(node.val);
                if(node.left != null){//下一层有节点，就把下一层添加进队列
                    queue.offer(node.left);
                }if(node.right != null){
                    queue.offer(node.right);
                }
            }
            size = queue.size();
            list2.add(list);
        }
        return list2;
    }
}

107. 二叉树的层序遍历 II

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例 1：

输入：root = [3,9,20,null,null,15,7]

输出：[[15,7],[9,20],[3]]

示例 2：

输入：root = [1]

输出：[[1]]

示例 3：

输入：root = []

输出：[]

提示：

  • 树中节点数目在范围 [0, 2000] 内

  • -1000 <= Node.val <= 1000

class Solution {
    //先从上往下，最后再倒序输出
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> list2 = new ArrayList<List<Integer>>();
        int size = 0;
        Queue<TreeNode> queue = new LinkedList<>();
        if(root == null){
            return list2;
        }
        queue.offer(root);
        size = queue.size();
        while(!queue.isEmpty()){
            List<Integer> list = new ArrayList<>();
            for(int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                list.add(node.val);
                if(node.left != null){
                    queue.offer(node.left);
                }if(node.right != null){
                    queue.offer(node.right);
                }
            }
            size = queue.size();
            list2.add(list);
        }
        List<List<Integer>> result = new ArrayList<List<Integer>>();//从上往下遍历完后，再倒序输出
        for(int i = list2.size() - 1; i >= 0; i--){
            result.add(list2.get(i));
        }

        return result;
    }
}

199. 二叉树的右视图

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

示例 1:

输入: [1,2,3,null,5,null,4]

输出: [1,3,4]

示例 2:

输入: [1,null,3]

输出: [1,3]

示例 3:

输入: []

输出: []

提示:

  • 二叉树的节点个数的范围是 [0,100]

  • -100 <= Node.val <= 100

class Solution {
    //一样是从上往下遍历，最后存储size - 1这个位置的元素就可以
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root == null){
            return list;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            for(int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right != null){
                    queue.offer(node.right);
                }
                if(i == size - 1){
                    list.add(node.val);
                }
            }
        }
        return list;
    }
}

637. 二叉树的层平均值

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

示例 1：

输入：root = [3,9,20,null,null,15,7]

输出：[3.00000,14.50000,11.00000]

解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。

因此返回 [3, 14.5, 11] 。

示例 2:

输入：root = [3,9,20,15,7]

输出：[3.00000,14.50000,11.00000]

提示：

  • 树中节点数量在 [1, 104] 范围内

  • -231 <= Node.val <= 231 - 1

class Solution {
    //因为size的控制，每一层都是知道的，把每一层的元素加起来，在除以层数的个数，得到平均值
    public List<Double> averageOfLevels(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<Double> result = new ArrayList<>();
        if(root == null){
            return result;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            double sum = 0.0;
            for(int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                sum += node.val;
                if(node.left != null){
                    queue.offer(node.left);
                }if(node.right != null){
                    queue.offer(node.right);
                }
            }
            result.add(sum / size);

        }
        return result;
    }
}

429. N 叉树的层序遍历

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

示例 1：

输入：root = [1,null,3,2,4,null,5,6]

输出：[[1],[3,2,4],[5,6]]

示例 2：

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]

输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

提示：

  • 树的高度不会超过 1000

  • 树的节点总数在 [0, 10^4] 之间

class Solution {
    //逐层遍历的改变在于孩子节点，这里用增强for循环把孩子节点一个一个取出来
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        Queue<Node> queue = new ArrayDeque<>();
        if(root == null){
            return result;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            List<Integer> list = new ArrayList<>();
            int size = queue.size();
            for(int i = 0; i < size; i++){
                Node node = queue.poll();
                list.add(node.val);
                if(node.children != null){
                    for(Node childrenNode : node.children){
                        queue.offer(childrenNode);
                    }
                }
            }
            result.add(list);
        }
        return result;
    }
}

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

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

示例1：

输入: root = [1,3,2,5,3,null,9]

输出: [1,3,9]

示例2：

输入: root = [1,2,3]

输出: [1,3]

提示：

  • 二叉树的节点个数的范围是 [0,104]

  • -231 <= Node.val <= 231 - 1

class Solution {
    //用list把每层元素记录下来，在遍历找出每层的最大值
    public List<Integer> largestValues(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<Integer> result = new ArrayList<>();
        if(root == null){
            return result;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            for(int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                list.add(node.val);
                if(node.left != null){
                    queue.offer(node.left);
                }if(node.right != null){
                    queue.offer(node.right);
                }
            }
            int maxNum = list.get(0);
            for(int i = 1; i < list.size(); i++){
                if(list.get(i) > maxNum){
                    maxNum = list.get(i);
                }
            }
            result.add(maxNum);
        }
        return result;
    }
}

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

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

struct Node {

int val;

Node *left;

Node *right;

Node *next;

}

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

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

示例 1：

输入：root = [1,2,3,4,5,6,7]

输出：[1,#,2,3,#,4,5,6,7,#]

解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。

示例 2:

输入：root = []

输出：[]

提示：

  • 树中节点的数量在 [0, 212 - 1] 范围内

  • -1000 <= node.val <= 1000

进阶：

  • 你只能使用常量级额外空间。

  • 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。

class Solution {
    //把每一层的元素增加一个next指针，指向下一个，最后一个不用指针，所以加了
    //if(i < size - 1)这个条件
    public Node connect(Node root) {
        Queue<Node> queue = new LinkedList<>();
        if(root == null){
            return root;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            for(int i = 0; i < size; i++){
                Node node = queue.poll();
                if(i < size - 1){
                    node.next = queue.peek();
                }
                if(node.left != null){
                    queue.offer(node.left);
                }if(node.right != null){
                    queue.offer(node.right);
                }
            }
        }
        return root;
    }
}

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

给定一个二叉树：

struct Node {

int val;

Node *left;

Node *right;

Node *next;

}

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

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

示例 1：

输入：root = [1,2,3,4,5,null,7]

输出：[1,#,2,3,#,4,5,7,#]

解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），'#' 表示每层的末尾。

示例 2：

输入：root = []

输出：[]

提示：

  • 树中的节点数在范围 [0, 6000] 内

  • -100 <= Node.val <= 100

进阶：

  • 你只能使用常量级额外空间。

  • 使用递归解题也符合要求，本题中递归程序的隐式栈空间不计入额外空间复杂度。

class Solution {
    //和116一模一样的代码，二叉树和完美二叉树没区别
    public Node connect(Node root) {
         Queue<Node> queue = new LinkedList<>();
        if(root == null){
            return root;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            for(int i = 0; i < size; i++){
                Node node = queue.poll();
                if(i < size - 1){
                    node.next = queue.peek();
                }
                if(node.left != null){
                    queue.offer(node.left);
                }if(node.right != null){
                    queue.offer(node.right);
                }
            }
        }
        return root;
    }
}

104. 二叉树的最大深度

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

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

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

示例：

给定二叉树 [3,9,20,null,null,15,7]，

3

/ \

9 20

/ \

15 7

返回它的最大深度 3 。

class Solution {
    //因为每层的临界点size都是知道的，所以没遍历一次size，深度加1就可以
    public int maxDepth(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        int deep = 0;
        if(root == null){
            return deep;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            for(int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                if(node.left != null){
                    queue.offer(node.left);
                }if(node.right != null){
                    queue.offer(node.right);
                }
            }
            deep++;
        }
        return deep;
    }
}

111. 二叉树的最小深度

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

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

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

示例 1：

输入：root = [3,9,20,null,null,15,7]

输出：2

示例 2：

输入：root = [2,null,3,null,4,null,5,null,6]

输出：5

提示：

  • 树中节点数的范围在 [0, 105] 内

  • -1000 <= Node.val <= 1000

class Solution {
    //最小深度就是找到没有孩子节点的位置。那么返回这个没有孩子节点所处位置的深度。
    //关键在if(node.left == null && node.right == null)
    public int minDepth(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        int deep = 0;
        if(root == null){
            return deep;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            deep++;
            for(int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right != null){
                    queue.offer(node.right);
                }
                if(node.left == null && node.right == null){
                    return deep;
                }    
            }
            
        }
        return deep;
    }
}

226. 翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

输入：root = [4,2,7,1,3,6,9]

输出：[4,7,2,9,6,3,1]

示例 2：

输入：root = [2,1,3]

输出：[2,3,1]

示例 3：

输入：root = []

输出：[]

提示：

  • 树中节点数目范围在 [0, 100] 内

  • -100 <= Node.val <= 100

class Solution {
    //用了广度遍历和递归两种方法，核心思想就是把root的左右子树看做两个孩子节点，交换孩子
    //相当于交换了自树，再递归下去，把每个节点的下一个子树都看做一个孩子节点。递归最后就能翻转
    //可以用画图进行辅助，比较容易理解
    public TreeNode invertTree(TreeNode root) {
        // if(root == null){
        //     return root;
        // }
        // Queue<TreeNode> queue = new LinkedList<>();
        // queue.offer(root);
        // while(!queue.isEmpty()){
        //     int size = queue.size();
        //     for(int i = 0; i < size; i++){
        //         TreeNode node = queue.poll();
        //         //if(node.left != null && node.right != null){
        //             TreeNode temp = node.left;
        //             node.left = node.right;
        //             node.right = temp;
        //         //}
        //         if(node.left != null){
        //             queue.offer(node.left);
        //         }
        //         if(node.right != null){
        //             queue.offer(node.right);
        //         }
        //     }
        // }
        // return root;
        if(root == null){
            return null;
        }
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
        invertTree(root.left);
        invertTree(root.right);
        return root;
    }
}

101. 对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例 1：

输入：root = [1,2,2,3,4,4,3]

输出：true

示例 2：

输入：root = [1,2,2,null,3,null,3]

输出：false

提示：

  • 树中节点数目在范围 [1, 1000] 内

  • -100 <= Node.val <= 100

进阶：你可以运用递归和迭代两种方法解决这个问题吗？

class Solution {
    //这道题用递归来解决，关键在于结束条件的判断，要把大部分可能性都罗列出来，不要只是if-else，因为可能会出现
    //遗漏条件。递归的核心在于把子树都看做是孩子节点，只要孩子相等，那么就可以看做相等，如果孩子相等，继续深入下一层，孩子的
    //孩子相等，相等变成compare(left.left,right.right);和compare(left.right,right.left);
    //也就是左孩子的左孩子等于右孩子的右孩子，左孩子的右孩子等于右孩子的做孩子，需要画图，比较清楚。
    public boolean isSymmetric(TreeNode root) {
        if(root == null){
            return false;
        }
        return compare(root.left,root.right);
    }
    public boolean compare(TreeNode left, TreeNode right){
        if(left == null && right == null){
            return true;
        }
        if(left == null && right != null){
            return false;
        }
        if(left != null && right == null){
            return false;
        }
        if(left.val != right.val){
            return false;
        }
        boolean s1 = compare(left.left,right.right);
        boolean s2 = compare(left.right,right.left);
        return s1&s2;
    }
}
石头走到哪里还是石头
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python-leetcode面试题解之第107题二叉树的层序遍历II.zip
04-29
python python_leetcode面试题解之第107题二叉树的层序遍历II
windhuiyi#leetcode#02-二叉树-广度遍历层序遍历1
07-25
public void helper(TreeNode root, int level){// 当前层没有 list，新建// 取得当前层的 list迭代pub
代码随想录算法训练营day15| 层序遍历 226.翻转二叉树
最新发布
Anzerwhite的博客
05-23 301
层序遍历，将每个弹出的元素的next指向队列中的front元素，并将每层最后一个元素指向nil。层序遍历，遇到叶子节点（左右子节点均为空）时即返回当前的depth。时间复杂度O(n) 空间复杂度O(n)时间复杂度O(n) 空间复杂度O(n)时间复杂度O(n) 空间复杂度O(n)时间复杂度O(n) 空间复杂度O(n)同理，将原来的遍历两个节点变成遍历n个节点。层序遍历后获取每层最右边的元素即可。层序遍历后，对每层的元素求和即可。层序遍历，记录最大值即可。
代码随想录【day 14 二叉树】| 层序遍历 226.翻转二叉树 101.对称二叉树
weixin_43891814的博客
02-08 663
代码随想录【day 14 二叉树】| 层序遍历 226.翻转二叉树 101.对称二叉树
代码随想录打卡day15|102. 二叉树的层序遍历226. 翻转二叉树101. 对称二叉树
weixin_56718399的博客
11-09 256
力扣打卡
录子训练营DAY15 | 102层序遍历 226.翻转二叉树 101.对称二叉树
m0_50899927的博客
12-04 172
代码随想录训练营day15
代码随想录训练营Day15|层序遍历|226.翻转二叉树|101.对称二叉树 2
yy19991222的博客
06-21 185
借助队列结构，保存每一层保存过的元素，size记录当前层大小，决定当前层弹出多少元素；弹出一个元素，就在后续加入他的左右子元素；一层结束，size==0后，队列中全为下一层元素，此时更新size，开始进行该层的弹出，以及下一层的压入。117.填充每个节点的下一个右侧节点指针II。116.填充每个节点的下一个右侧节点指针。107.二叉树的层次遍历II。如何一层一层的保存节点？102.二叉树的层序遍历。637.二叉树的层平均值。104.二叉树的最大深度。111.二叉树的最小深度。199.二叉树的右视图。
代码随想录算法训练营第15日 | 层序遍历 226.翻转二叉树 101.对称二叉树 2
lebowskii的博客
10-06 231
day15
代码随想录算法训练营-day15-102. 二叉树的层序遍历、226. 翻转二叉树、101. 对称二叉树
weixin_47067912的博客
11-14 311
代码随想录算法训练营-day15（补打卡）
代码随想录训练营Day15：层序遍历、226.翻转二叉树 、101.对称二叉树
minixiaoxiaozhu的博客
10-06 294
层序遍历、226.翻转二叉树 、101.对称二叉树
代码随想录Day15——层序遍历 226.翻转二叉树 101. 对称二叉树
cheng_dog的博客
11-08 989
使用队列，将每一层的元素入队，并记录每层元素个数，再该层每一个元素从队头出队时将其子节点从队尾入队，这样当上层元素全部出队后，其下层元素全部入队，重复上述操作，直到队列为空。下边11道题均可以使用该方法解决。给你二叉树的根节点root，返回其节点值的。（即逐层地，从左到右访问所有节点）。给你二叉树的根节点root，返回其节点值。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）给定一个二叉树的root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
代码随想录算法训练营Day15 | 二叉树(2/9) LeetCode 层序遍历 226.翻转二叉树 101.对称二叉树
记录学习每一天！
08-17 58
二叉树练习第二天，思路最重要！
8606-二叉树的构建及遍历操作.rar_二叉树_遍历算法
09-21
实现二叉树的遍历操作，属于数据结构基础算法，代码能够顺利运行，运行环境是ColdBlick。
完全二叉树的层序遍历-labview
12-20
完全二叉树的层序遍历-labview完全二叉树的层序遍历-labview完全二叉树的层序遍历-labview完全二叉树的层序遍历-labview完全二叉树的层序遍历-labview完全二叉树的层序遍历-labview完全二叉树的层序遍历-labview完全...
js代码-二叉树的层序遍历
07-16
js代码-二叉树的层序遍历
质数和约数
2302_77099705的博客
05-21 1117
最大公约数（Greatest Common Divisor）指两个或多个整数共有约数中最大的一个。也称最大公因数、最大公因子，a， b的最大公约数记为（a，b），同样的，a，b，c的最大 公约数记为（a，b，c），多个 整数的最大公约数也有同样的记号。求最大公约数有多种 方法，常见的有 质因数分解法、 短除法、 辗转相除法、 更相减损法。
算法训练营36
stmfresher的博客
05-22 174
代码随想录上的思路，让加油 - 耗油，如果所有的总和都<0 那肯定跑不完，然后用一个currsum 统计从 0 开始到当前i 的 剩余油之和，如果 < 0 说明 起始位置肯定在为 i + 1，然后currsum 置零，在重复上面操作，最后返回 start 就行。这道题从两边开始算就好，先从左向右只考虑右边小孩比左边小孩大，然后从右向左考虑，最后取两次糖果数组里大的，然后最后求和即可。根据通过情况反复挑战最终AC过了，这里和原来的差别是他的排序是用绝对值排序的，这样的思路会很简单。
每日一题（PTA Advanced1003）：Emergency-dfs
m0_75015083的博客
05-22 120
【代码】每日一题（PTA Advanced1003）：Emergency-dfs。
代码随想录算法训练营Day 45|动态规划part07| 70. 爬楼梯 （进阶）、322. 零钱兑换、279.完全平方数
m0_51759998的博客
05-20 268
dp[i]：爬到有i个台阶的楼顶，有dp[i]种方法。
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例。该代码使用了递归法的前序遍历，对于每一个节点，交换其左右子节点，然后递归地对其左右子树进行翻转。 引用中给出了一个实现二叉树的层序遍历的代码示例。该代码使用了BFS的思想，借助队列来实现层序遍历。每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列，同时将当前层的节点值添加到结果列表中。 综上所述，参考这些引用，可以通过BFS来实现二叉树的层序遍历，并通过递归法或迭代法来翻转二叉树。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值