leetcode打卡-二叉树I

最新推荐文章于 2024-07-23 16:17:06 发布
最新推荐文章于 2024-07-23 16:17:06 发布
阅读量94 收藏
点赞数
分类专栏： 算法 文章标签： leetcode 算法 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43093878/article/details/129108128
版权

目录

102. 二叉树的层序遍历

429. N 叉树的层序遍历

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

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

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

104. 二叉树的最大深度

111. 二叉树的最小深度

 199. 二叉树的右视图

637. 二叉树的层平均值

107. 二叉树的层序遍历 II

100. 相同的树

 572. 另一棵树的子树

 94. 二叉树的中序遍历

145. 二叉树的后序遍历

 144. 二叉树的前序遍历

101. 对称二叉树

222. 完全二叉树的节点个数

 226. 翻转二叉树

102. 二叉树的层序遍历

leetcode题目链接：https://leetcode.cn/problems/binary-tree-level-order-traversal

leetcode AC记录：

思路：使用队列存放每一层的节点， 循环取每一层节点前使用当前队列大小当作每层节点个数。

代码如下：

public List<List<Integer>> levelOrder(TreeNode root) {
        Deque<TreeNode> queue = new LinkedList<>();
        if(root == null) {
            return new ArrayList<>();
        }

        queue.offer(root);

        List<List<Integer>> res = new ArrayList<>();
        while(!queue.isEmpty()) {
            List<Integer> list = new ArrayList<>(queue.size());
            int size = queue.size();
            for(int i = 0;i < size;i++) {
                TreeNode node = queue.pollFirst();
                list.add(node.val);
                if(node.left != null) {
                    queue.offer(node.left);
                }

                if(node.right != null) {
                    queue.offer(node.right);
                }
            }

            res.add(list);
        }

        return res;
    }

429. N 叉树的层序遍历

leetcode题目链接：https://leetcode.cn/problems/n-ary-tree-level-order-traversal

leetcode AC记录：

 代码如下：

public List<List<Integer>> levelOrder(Node root) {
        if(root == null) {
            return new ArrayList<>(0);
        }

        List<List<Integer>> res = new ArrayList<>(16);
        Deque<Node> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> list = new ArrayList<>(size);
            for(int i = 0;i < size;i++) {
                Node node = queue.pollFirst();
                list.add(node.val);
                if(node.children != null && node.children.size() > 0) {
                    for(Node child : node.children) {
                        queue.offer(child);
                    }
                }
            }
            res.add(list);
        }
        return res;
    }

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

leetcode题目链接：https://leetcode.cn/problems/find-largest-value-in-each-tree-row

leetcode AC记录：

代码如下：

public List<Integer> largestValues(TreeNode root) {
        if(root == null) {
            return new ArrayList<>(0);
        }

        Deque<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        List<Integer> res = new ArrayList<>(16);
        int max;
        while(!queue.isEmpty()) {
            int size = queue.size();
            max = Integer.MIN_VALUE;
            for(int i = 0;i < size;i++) {
                TreeNode node = queue.pollFirst();
                if(node.val > max) {
                    max = node.val;
                }

                if(node.left != null) {
                    queue.offer(node.left);
                }

                if(node.right != null) {
                    queue.offer(node.right);
                }
            }
            res.add(max);
        }

        return res;
    }

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

leetcode题目链接：https://leetcode.cn/problems/populating-next-right-pointers-in-each-node

 leetcode AC记录：

思路：层序遍历，使用队列遍历每层，节点下一个指针指向队列中的下一个元素。

代码如下：

public Node connect(Node root) {
        if(root == null) {
            return null;
        }

        Deque<Node> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()) {
            int size = queue.size();
            int index = 0;
            while(index < size) {
                Node node = queue.pollFirst();
                if(index + 1 < size) {
                    node.next = queue.peek();
                } else {
                    node.next = null;
                }
                
                if(node.left != null) {
                    queue.offer(node.left);
                }

                if(node.right != null) {
                    queue.offer(node.right);
                }
                index++;
            }
        }

        return root;
    }

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

leetcode题目链接：https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii

leetcode AC记录：

代码如下：

 public Node connect(Node root) {
        if(root == null) {
            return null;
        }

        Deque<Node> queue = new LinkedList<>();
        queue.offer(root);

        while(!queue.isEmpty()) {
            int size = queue.size();
            int index = 0;
            while(index < size) {
                Node node = queue.pollFirst();
                if(index + 1 < size) {
                    node.next = queue.peek();
                }

                if(node.left != null) {
                    queue.offer(node.left);
                }

                if(node.right != null) {
                    queue.offer(node.right);
                }
                index++;
            }
        }
        return root;
    }

104. 二叉树的最大深度

leetcode题目链接：https://leetcode.cn/problems/maximum-depth-of-binary-tree

leetcode AC记录：

思路：层序遍历，记录层数。

代码如下：

public int maxDepth(TreeNode root) {
        if(root == null) {
            return 0;
        }

        int res = 0;
        Deque<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()) {
            int size = queue.size();
            int index = 0;
            while(index < size) {
                TreeNode node = queue.pollFirst();
                if(node.left != null) {
                    queue.offer(node.left);
                }
                if(node.right != null) {
                    queue.offer(node.right);
                }
                index++;
            }
            res++;
        }
        return res;
    }

111. 二叉树的最小深度

leetcode题目链接：https://leetcode.cn/problems/minimum-depth-of-binary-tree

leetcode AC记录：

思路：层序遍历，如果碰到叶子节点，返回层数。

代码如下：

public int minDepth(TreeNode root) {
        if(root == null) {
            return 0;
        }

        Deque<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int res = 1;
        while(!queue.isEmpty()) {
            int size = queue.size();
            int index = 0;
            while(index < size) {
                TreeNode node = queue.pollFirst();
                if(node.left == null && node.right == null) {
                    return res;
                }
                
                 if(node.left != null) {
                    queue.offer(node.left);
                }

                if(node.right != null) {
                    queue.offer(node.right);
                }
                index++;
            }
            res++;
        }
        return res;
    }

 199. 二叉树的右视图

leetcode题目链接：https://leetcode.cn/problems/binary-tree-right-side-view/

leetcode AC记录：

思路：层序遍历，收取每层最后一个节点就是结果。

代码如下：

public List<Integer> rightSideView(TreeNode root) {
        if(root == null) {
            return new ArrayList<>(0);
        }

        List<Integer> res = new ArrayList<>(16);
        Deque<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()) {
            int size = queue.size();
            int index = 0;
            while(index < size) {
                TreeNode node = queue.pollFirst();

                if(node.left != null) {
                    queue.offer(node.left);
                }

                if(node.right != null) {
                    queue.offer(node.right);
                }

                if(index + 1 == size) {
                    res.add(node.val);
                }
                index++;
            }
        }

        return res;
    }

637. 二叉树的层平均值

leetcode题目链接：https://leetcode.cn/problems/average-of-levels-in-binary-tree

leetcode AC记录：

思路：层序遍历，每层求平均值。

代码如下：

public List<Double> averageOfLevels(TreeNode root) {
        if(root == null) {
            return new ArrayList<>(0);
        }

        List<Double> res = new ArrayList<>();
        Deque<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()) {
            int size = queue.size();
            int index = 0;
            Double sum = 0.0;
            while(index < size) {
                TreeNode node = queue.pollFirst();
                sum += node.val;

                if(node.left != null) {
                    queue.offer(node.left);
                }
                if(node.right != null) {
                    queue.offer(node.right);
                }
                index++;
            }
            res.add(sum / size);
            
        }
        return res;
    }

107. 二叉树的层序遍历 II

leetcode题目链接：https://leetcode.cn/problems/binary-tree-level-order-traversal-ii

leetcode AC记录：

思路：层序遍历，使用头插法保存结果。

代码如下：

public List<List<Integer>> levelOrderBottom(TreeNode root) {
        if(root == null) {
            return new ArrayList<>(0);
        }

        List<List<Integer>> res = new ArrayList<>(16);
        Deque<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while(!queue.isEmpty()) {
            int size = queue.size();
            int index = 0;
            List<Integer> list = new ArrayList<>(size);
            while(index < size) {
                TreeNode node = queue.pollFirst();
                if(node.left != null) {
                    queue.offer(node.left);
                }
                if(node.right != null) {
                    queue.offer(node.right);
                }
                list.add(node.val);
                index++;
            }
            res.add(0, list);
        }
        return res;
    }

100. 相同的树

leetcode题目链接：https://leetcode.cn/problems/same-tree

leetcode AC记录：

思路：递归比较左右子树。

代码如下：

public boolean isSameTree(TreeNode p, TreeNode q) {
        return isSameTreeTravel(p, q);
    }

    public boolean isSameTreeTravel(TreeNode p, TreeNode q) {
        if(p == null && q == null) {
            return true;
        } else if(p == null && q != null) {
            return false;
        } else if(p != null && q == null) {
            return false;
        } else if(p.val != q.val) {
            return false;
        }

        return isSameTreeTravel(p.left, q.left) && isSameTreeTravel(p.right, q.right);
    }

 572. 另一棵树的子树

leetcode题目链接：https://leetcode.cn/problems/subtree-of-another-tree

leetcode AC记录：

思路：遍历主树，使用递归比较，和上题类似。

代码如下：

public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        Deque<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()) {
            TreeNode node = queue.pollFirst();
            if(isSameTree(node, subRoot)) {
                return true;
            } else {
                if(node.left != null) {
                    queue.offer(node.left);
                }
                if(node.right != null) {
                    queue.offer(node.right);
                }
            }
        }
        return false;
    }

    public boolean isSameTree(TreeNode p, TreeNode q) {
        if(p == null && q == null) {
            return true;
        } else if(p == null && q != null) {
            return false;
        } else if(p != null && q == null) {
            return false;
        } else if(p.val != q.val) {
            return false;
        }

        boolean flag1 = isSameTree(p.left, q.left);
        boolean flag2 = isSameTree(p.right, q.right);
        return flag1 && flag2;
    }

 94. 二叉树的中序遍历

leetcode题目链接：https://leetcode.cn/problems/binary-tree-inorder-traversal

leetcode AC记录：

思路：

        方法1:递归法，按照左根右的递归顺序。

        方法2:迭代法，使用栈和指针，指针初始化为根节点，如果指针不为空，指针赋值为当前节点的左节点，如果为空，取栈顶元素，指针指向栈顶元素，输出并将其赋值为当前节点的右节点。

代码如下：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>(16);

        // traversal(root, res);
        // return res;
        return traversal(root);
    }

    public void traversal(TreeNode node, List<Integer> res) {
        if(node == null) {
            return;
        }

        traversal(node.left, res);
        res.add(node.val);
        traversal(node.right, res);
    }

    /**
     * 迭代法中序遍历
     * 左中右
     */
    public List<Integer> traversal(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        if(root == null) {
            return new ArrayList<>(0);
        }
        List<Integer> res = new ArrayList<>(16);
        TreeNode cur = root;
        while(cur != null || !stack.empty()) {
            if(cur != null) {
                stack.push(cur);
                cur = cur.left;
            } else {
                TreeNode node = stack.pop();
                res.add(node.val);
                cur = node.right;
            }
        }
        return res;
    }
}

145. 二叉树的后序遍历

leetcode题目链接：https://leetcode.cn/problems/binary-tree-postorder-traversal

leetcode AC记录：

思路：

        方法1:递归，按照左右根的顺序进行递归。

        方法2:迭代，按照根左右的顺序入栈节点，取的顺序为根右左，然后对结果数组进行反转。

代码如下：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>(16);
        // traversal(root, res);
        // return res;
        return traversal1(root);
    }

    //递归法
    public void traversal(TreeNode node, List<Integer> res) {
        if(node == null) {
            return;
        }

        traversal(node.left, res);
        traversal(node.right, res);

       
        res.add(node.val);
    }

    //迭代法
    public List<Integer> traversal1(TreeNode root) {
        if(root == null) {
            return new ArrayList<>(0);
        }

        List<Integer> res = new ArrayList<>(16);
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while(!stack.empty()) {
            TreeNode node = stack.pop();
            
            res.add(node.val);
            
            //左右中，中右左后反转
            if(node.left != null) {
                stack.push(node.left);
            }
            if(node.right != null) {
                stack.push(node.right);
            }
        }
        Collections.reverse(res);
        return res;

    }
}

 144. 二叉树的前序遍历

leetcode题目链接：https://leetcode.cn/problems/binary-tree-preorder-traversal

leetcode AC记录：

思路：

        方法1: 递归法，按照根左右的顺序递归。

        方法2: 迭代法，按照根右左的顺序入栈， 按照根左右的顺序出栈处理。

代码如下：

public List<Integer> preorderTraversal(TreeNode root) {
        TreeNode node = root;
        List<Integer> res = new ArrayList<>(16);
        //递归法
        // traversal1(node, res);
        // return res;
         return traversal1(node);
    }

    /**
     * 递归法
     */
    public void traversal(TreeNode node, List<Integer> res) {
        if(node == null) {
            return;
        }

        res.add(node.val);
        traversal(node.left, res);
        traversal(node.right, res);
    }

    /**
     * 迭代法,使用栈解决
     */
     public List<Integer> traversal1(TreeNode root) {
        if(root == null) {
            return new ArrayList<>(0);
         }

        List<Integer> res = new ArrayList<>(16);
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while(!stack.empty()) {
            TreeNode node = stack.pop();
            res.add(node.val);
            if(node.right != null) {
                stack.push(node.right);
            }

            if(node.left != null) {
                stack.push(node.left);
            }
        }

        return res;
     }

101. 对称二叉树

leetcode题目链接：https://leetcode.cn/problems/symmetric-tree

leetcode AC记录：

思路：递归遍历左右子树，进行判断。

代码如下：

public boolean isSymmetric(TreeNode root) {
        if(root == null) {
            return true;
        }
        return isSymmetric(root.left, root.right);
    }

    public boolean isSymmetric(TreeNode left, TreeNode right) {
        if(left == null && right == null) {
            return true;
        } else if(left == null && right != null) {
            return false;
        } else if(left != null && right == null) {
            return false;
        } else if(left.val != right.val) {
            return false;
        }

        boolean flag1 = isSymmetric(left.right, right.left);
        boolean flag2 = isSymmetric(left.left, right.right);
        return flag1 && flag2;
    }

222. 完全二叉树的节点个数

leetcode题目链接：https://leetcode.cn/problems/count-complete-tree-nodes

leetcode AC记录：

代码如下：

 public int countNodes(TreeNode root) {
        if(root == null) {
            return 0;
        }

        return countNodes(root.left) + countNodes(root.right) + 1;
    }

 226. 翻转二叉树

leetcode题目链接：https://leetcode.cn/problems/invert-binary-tree/

leetcode AC记录：

代码如下：

public TreeNode invertTree(TreeNode root) {
        invert(root);
        return root;
    }

    public void invert(TreeNode root) {
        if(root == null) {
            return;
        }

        TreeNode left = root.left;
        root.left = root.right;
        root.right = left;

        invert(root.left);
        invert(root.right);
    }
川夜施密特
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode 二叉树
cuicui_ruirui的博客
07-27 295
一、重建二叉树 题目描述：输入某二叉树的前序遍历和中序遍历的结果，请构建该二叉树并返回其根节点。假设输入的前序遍历和中序遍历的结果中都不含重复的数字 思路：第一次：前序遍历中的第一个节点为根节点，需要在中序遍历中找到与根节点值相同的节点所在的索引。每次找都遍历一次中序遍历效率低。考虑将中序遍历存在字典中，将中序遍历中的值当做键，索引当做值。 因此在执行递归之前先遍历中序遍历并存在字典中 后续：在递归函数中主要做三件事：1找到当前根节点在中序遍历中的索引 2建立根节点 3建立左右节点的递归，左子...
leetcode卡-Leetcode-Practice:Leetcode刷题打卡
07-06
2. **主题分类**：LeetCode的题目按照主题分类，如数组、链表、二叉树等，可以按照自己的薄弱领域选择题目进行练习。 3. **定期打卡**：“LeetCode Practice”项目鼓励用户进行每日或每周的刷题打卡，以保持学习的...
【LeetCode】-二叉树
银尘博客
03-15 7706
文章目录前言一、二叉树的层序遍历 前言 初识LeetCode与算法，将在此系列文章里面，记录自己的算法学习经历，前期主要是监督自己学习打卡，后期我会将自己对知识的理解，慢慢补充到文章当中，希望大家能在阅读我的文章中，有所收获。该系列文章的刷题顺序以代码随想录为线索。 一、二叉树的层序遍历 题目： 给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。 示例 1： 输入：root = [3,9,20,null,null,15,7] 输出：[[3],[9,20],[1
leetcode打卡-二叉树II
川夜施密特的博客
02-25 161
leetcode打卡：二叉树II
leetcode打卡-贪心算法
川夜施密特的博客
03-12 323
贪心算法
leetcode卡-LeetCode:力扣打卡
07-06
"LeetCode卡"可能指的是用户在LeetCode上进行日常练习的一种方式，类似于学习或打卡计划。 在LeetCode的开源项目"LeetCode-master"中，我们可能找到一个与LeetCode平台相关的代码库，它可能是为了帮助用户更方便地...
leetcode卡-leetcode:使用JavaScript打卡leetCode题目
07-06
在使用JavaScript打卡LeetCode的过程中，你可能会遇到以下知识点： 1. **基本数据类型与引用类型**：JavaScript有七种基本数据类型（null、undefined、boolean、number、string、symbol和BigInt）以及一种引用类型...
leetcode卡-java-leetcode:leetcode算法学习打卡
07-06
这个“leetcode卡-java-leetcode:leetcode算法学习打卡”项目似乎是一个针对Java开发者的LeetCode学习资源，它可能包含了代码示例、解题策略以及每日学习计划。"系统开源"的标签表明该项目是开放源代码的，这意味着...
leetcode下载-ARTS-:ARTS打卡
06-29
ARTS打卡 Algorithm Leetcode -111 Minimum Depth of Binary Tree 本题的要求是给一个二叉树，返回这个二叉树的最小层级 Tips Tmux 基本操作： prefix := Ctrl+B session相关操作 查看/切换session prefix s 离开...
力扣 102题 二叉树的层次遍历 记录
m0_49800270的博客
07-22 372
队列是一种先进先出（FIFO）的数据结构，非常适合于层序遍历，因为我们总是希望按照从树的上层到下层的顺序处理节点。队列操作：使用一个队列来管理待处理的树节点。队列的先进先出特性保证了树的每一层都按照从左到右的顺序被处理。
stack(leetcode练习题,牛客)
2301_81692739的博客
07-19 403
最开始写的，总会有一些样例过不了，没考虑全，后来看题解上的方法，将下标压入栈中，用右括号的下标减去栈顶下标，就是有效长度。不然只顾着最长，反而无法得到正确的有效长度。一个完整的括号，要么是1，要么里边包含其他括号，进行了 *2。所以，可以每遇到一个右括号，进行一次运算，第一次为 1，以后每次乘二，累加到栈顶。遇到左括号，就向栈压入0，重新运算，当遇到右括号，再弹出.如果数字比栈顶小就压入，否则，将栈顶删除直到，比栈顶小或这栈为空。关于stack的知识，可以看点击查看上面的博客，以下题目全在。
【LeetCode】分隔链表
qq_26521261的博客
07-20 385
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 330
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
LeetCode 188题： 买卖股票的最佳时机IV优化（原创）
it_fly的专栏
07-21 226
算法思路：1.买了j次的最大获利值等于：昨天买了j次，和昨天卖了j-1次，今天再买的最大值；2.卖了j次的最大获利值等于：昨天卖了j次，和昨天买了j次，今天再卖掉的最大值
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 127
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
【LeetCode】80.删除有序数组中的重复项II
说文科技，做有态度的研究。
07-21 147
思路很好想到，但是实现起来不是那么容易。
leetcode4 -- 寻找两个正序数组的中位数
最新发布
m0_65985318的博客
07-23 66
先将两数组合并，然后利用sort排序算法，对数组进行从小到大的排序，根据总长度是奇数或者偶数来决定中位数的位置。合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5。合并数组 = [1,2,3] ，中位数 2。请你找出并返回这两个正序数组的。的正序（从小到大）数组。算法的时间复杂度应该为。
C++ | Leetcode C++题解之第275题H指数II
Ddddddd_158的博客
07-23 206
C++ | Leetcode C++题解之第275题H指数II
idea leetcode-edito乱码
09-01
LeetCode-Editor是一种在线编码工具，它提供了一个用户友好的界面编写和运行代码。在使用LeetCode-Editor时，有时候会出现乱码的问题。 乱码的原因可能是由于编码格式不兼容或者编码错误导致的。在这种情况下，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值