代码随想录day13(补卡) 二叉树部分 递归遍历前序后序中序144|145 |94 层序遍历 102|107|199|637|429|515|116|117|104|111

最新推荐文章于 2024-09-14 22:25:23 发布
最新推荐文章于 2024-09-14 22:25:23 发布
阅读量687 收藏 17
点赞数 21
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38788700/article/details/141086172
版权

144 二叉树的前序遍历|145 二叉树的后序遍历|94 二叉树的中序遍历

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

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

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

思路：中左右，左右中，左中右

/**
 * 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:
    void traversal(TreeNode* cur,vector<int>& vec){
        if(cur == nullptr)
        return;
        //确定单层遍历逻辑
        vec.push_back(cur->val);
        traversal(cur->left, vec);
        traversal(cur->right, vec); 
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root,result);
        return result;


    }
};
/**
 * 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:
    void traversal(TreeNode* cur, vector<int>& vec){
        if(cur == nullptr)
        return;
        traversal(cur->left, vec);
        traversal(cur->right, vec);
        vec.push_back(cur->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};
/**
 * 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:
    void traversal(TreeNode* cur, vector<int>& vec){
        if(cur == nullptr)
        return;
        traversal(cur->left, vec);
        vec.push_back(cur->val);
        traversal(cur->right, vec);
        
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;

    }
};

102 二叉树的层序遍历

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

思路：由队列先进先出特性完成广度优先搜索遍历，队列的size很重要，弹出size个元素标志二叉树每层有多少个元素。

/**
 * 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;
        if(root != nullptr)
        que.push(root);
         vector<vector<int>> result;
         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);
            }
            result.push_back(vec);
         }
         return result;
    }
};

107 二叉树的层序遍历||

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

思路：反转result数组得自底向上的层序遍历

/**
 * 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>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != nullptr)
        que.push(root);
        vector<vector<int>> result;
        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);
            }
            result.push_back(vec);
        }
        reverse(result.begin(),result.end());  //反转result数组得自底向上遍历
        return result;
    }
};

199 二叉树的右视图

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

思路:判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，最后返回result。

/**
 * 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<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != nullptr)
        que.push(root);
        vector<int> result;
        while(!que.empty()){
            int size = que.size();
            for (int i = 0;i<size; i++){
                TreeNode* node = que.front();
                que.pop();
                if(i == (size - 1))
                result.push_back(node->val); //将每一层最后元素放入result数组中
                if(node->left)
                que.push(node->left);
                if(node->right)
                que.push(node->right);
            }
        }
        return result;
    }
};

637 二叉树的层平均值

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

思路：统计每层的和再求均值并放进结果集。

/**
 * 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<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != nullptr)
        que.push(root);
        vector<double> result;
        while(!que.empty()){
            int size = que.size();
            double sum = 0;  //  统计每一层的和
            for (int i=0; i < size; i++){
                TreeNode* node = que.front();
                que.pop();
                sum += node->val;
                if(node->left) 
                que.push(node->left);
                if(node->right) 
                que.push(node->right);
            }
            result.push_back(sum / size);  //对每层求总和再取一个均值，并将均值放进结果集。
        }
        return result;
    }
};

429 N插叉树的层序遍历

https://leetcode.cn/problems/n-ary-tree-level-order-traversal/description/

/*
// 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;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
      queue<Node*> que;
      if(root != nullptr )
      que.push(root);
      vector<vector<int>> result;
      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 j = 0; j < node->children.size(); j++){
                //将节点所有孩子加入队列
                if(node->children[j])
                que.push(node->children[j]);
            }
        }
        result.push_back(vec);
      }  
      return result;
    }
};

515 在每个树行中找最大值

https://leetcode.cn/problems/find-largest-value-in-each-tree-row/description/

/**
 * 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<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != nullptr)
        que.push(root);
        vector<int> result;
        while(!que.empty()){
            int size = que.size();
            int maxValue = INT_MIN; //取每一层的最大值
            for(int i = 0; i< size; i++){  //每层进行一次循环
                TreeNode*node = que.front();
                que.pop();
                maxValue = node->val > maxValue ? node->val : maxValue;
                if(node->left)
                que.push(node->left);
                if(node->right)
                que.push(node->right);
            }
            result.push_back(maxValue); //把最大值放入result数组
        }
        return result;
    }
};

116|117 填充每个节点的下一个右侧节点指针1和2

https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/description/

https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/description/

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
       queue<Node*> que;
       if(root!= NULL)
       que.push(root);
       while(!que.empty()){
        int size = que.size();
        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; //将nodePre移动到下一个节点
            }
            if(node->left)
            que.push(node->left);
            if(node->right)
            que.push(node->right);
        }
            nodePre->next = NULL;  //本层最后一个节点指向null
       } 
       return root;
    }
};
/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
       queue<Node*> que;
       if(root!= NULL)
       que.push(root);
       while(!que.empty()){
        int size = que.size();
        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; //将nodePre移动到下一个节点
            }
            if(node->left)
            que.push(node->left);
            if(node->right)
            que.push(node->right);
        }
            nodePre->next = NULL;  //本层最后一个节点指向null
       } 
       return root;
    }
};

104 二叉树的最大深度

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

思路：最大的深度就是二叉树的层数。

/**
 * 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:
    int maxDepth(TreeNode* root) {
        if(root == nullptr)
        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;
    }
};

111 二叉树的最小深度

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

思路：当左右孩子为空的时候可以判定，这是遍历的叶子结点了，也就是最小深度。

/**
 * 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:
    int minDepth(TreeNode* root) {
        if(root == nullptr)
        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);
                if(!node->left && !node->right) //左右孩子都为空说明就是最低点了
                return depth;
            }
        }
        return depth;
    }
};

 

qq_38788700
关注
Vue2/3 - 实现手机移动端H5网页日历组件|定位签到打卡|缺卡补卡功能效果，在vue移动端h5页面中完成自定义日历组件，在日历中显示是否打卡或缺卡（类似钉钉打卡，详细示例源代码，一键复制开箱即用
高级前端工程师
02-29 2950
vue2，vue3，手机移动端，移动端h5网页网站，h5页面，日历组件，日历签到打卡插件，日历补卡缺卡信息组件，前端vue日历带签到功能，vue移动端自定义日历定位打卡功能，vue日历带签到功能，vue3如何实现日历上有补卡签到功能，vue2怎么实现类似钉钉的签到打卡，vue日历+签到+缺卡打卡示例代码教程，vue定位打卡，vue实现考勤日历组件，vue打卡功能，vue实现钉钉的考勤日历，vue实现移动端日历打卡，vue自定义日历，自定义日历-实现签到订约功能，用日历插件实现签到功能，每日签到功能，vue日
[FineReport]实现用户自定义查询月考勤记录
德仔
12-23 3439
员工一定是非常关心自己的考勤记录，在很多企业的做法是，如果由于特殊原因：忘带卡，刷卡异常等，是可以通过考勤异常单据向HR申请补卡。 之前我也做过考情记录查询，但是界面不够友好。如何提供一个界面友好，随时可以查询考勤记录呢？ 主要思路： (1)抓取考勤记录表 (2)自定义生成整月日历：包含(上下班) (3)根据公司HR规则，区别旷工，迟到，早退等 (4)同时计算出第几周与星期几 (5)利用f
代码随想录算法训练营day15|LeetCode102二叉树的层序遍历、LeetCode226翻转二叉树、LeetCode101对称二叉树(补卡)
m0_66412823的博客
01-14 460
LeetCode102二叉树的层序遍历。LeetCode226翻转二叉树。LeetCode101对称二叉树。
代码随想录day15 补卡 ● 层序遍历 10 ● 226.翻转二叉树 ● 101.对称二叉树 2
Emiyan的博客
01-28 315
层序遍历考研中有学过，这里又熟悉了数遍，熟悉了迭代的模板，剩下的几道题相对来说算是比较简单的，只要在模板的基础上做修改就可以了。226.翻转二叉树。
代码随想录训练营第十四天 | 二叉树基础 递归遍历 144前序遍历 145后序遍历 94中序遍历
Sherry_Sky的博客
11-30 260
代码随想录训练营打卡Day14 | 二叉树基础 递归遍历 144前序遍历 145后序遍历 94中序遍历
代码随想录刷题思路与心得11|前序，中序和后序遍历二叉树
weixin_64693723的博客
10-04 496
代码随想录学习
一起自律打卡 | 简单介绍我开发的小程序
小白求学进阶
08-04 1132
新开发的一个有趣小程序：一起自律打卡 在实战中成长
行业趋势｜HRSSC3.0时代：AI助手升级员工服务
Askbotcn的博客
12-15 292
员工AI助手通过语义计算快速识别问题，精准匹配解决方案和对应处理流程，给予员工即时支持，省去等待时间，并通过自动化工单处理的方式，降低人工操作和系统对接的协同成本。
人脸离线识别SDK案例合集 | 持续更新
百度大脑
04-22 2560
人脸离线识别SDK介绍 人脸离线识别SDK，是将人脸检测与采集、活体检测、人脸对比与识别、人脸库管理等能力全部离线化、本地化的产 品，用户可基于该SDK开发各类离线人脸识别应用、智能设备或解决方案。 查看详情：https://ai.baidu.com/tech/face/offline-sdk 案例合集 智慧医疗场景 看病不用带卡，刷脸就医新体验——杭州市民卡有限公司 2019年，在百度大脑人...
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
qq_61936886的博客
09-12 392
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1113
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 267
试除法求约数、约数个数、约数之和、最大公约数
深度优先算法，广度优先算法，hill climbing，贪心搜索，A*算法，启发式搜索算法是什么，比起一般搜索法算法有什么区别
mimo_mimo的博客
09-10 1152
A算法通过维护一个优先队列（通常是最小堆），并根据启发式函数（如g(n) + h(n)，其中g(n)是从起点到当前点的实际距离，h(n)是从当前点到目标点的估计距离）来评估节点的优先级。它从图的某个顶点V0开始，依次访问V0的各个未被访问过的邻接点，然后从这些邻接点出发，再依次访问它们的未被访问过的邻接点，直到图中所有已被访问过的顶点的邻接点都被访问到。它从当前的节点开始，和周围的邻居节点的值进行比较，如果当前节点不是最大的，就用最高的邻居节点来替换当前节点，从而实现向“山峰”的高处攀爬的目的。
C语言程序设计-练习篇
最新发布
2402_85207276的博客
09-14 929
·三角形的判断 ·使用指针打印数组内容 ·字符串逆序 ·计算求和 ·打印水仙花数
Codeforces Round 969 (Div. 2) C. Dora and C++ （裴蜀定理）
2302_79440616的博客
09-10 444
取模，这样就能够得到所有数的最简形式（可以当成是让所有数尽可能消去。所以在这时候我们就可以让输入的所有数都去对。那么在取模之后我们现在排序，得到的极差就是。可以想到使用同样是需要给出两个定值的。由于这里给出了a和b两个数，我们。的判断，因为不排除有这种情况存在。，那么这里我们还要进行一次。，这样我们会取到最优解。
leecode100题-双指针-三数之和
kian9one的博客
09-10 418
固定i，即可转换为寻找满足 nums[l]+nums[r]=−nums[i] 的三元组，因为不能包含重复的三元组，以下两个三元组只能取一个，而后我们再考虑其是否满足 nums[l]+nums[r]=−nums[i]。先对数组排序，设一非递减的数组示例和初始三指针位置及名字如下所示。不同的三元组是 [-1,0,1] 和 [-1,-1,2]。移动指针的时候，需要规避连续的重复元素。答案中不可以包含重复的三元组。，判断是否存在三元组。
拥塞控制算法为何失效，网络为何难以测量？
Netfilter
09-14 1574
所以你知道实验室仿真的宇宙第一算法为啥拉了吧，也就不用再问为什么部署了 bbr 却还不如 cubic 了吧，如果你还希望研发一个精准的，普适的端到端算法，我劝你改行去卖皮鞋，至少还有很多经理市场。这和上一篇说的测量系统容量的方法并不矛盾，因为对于网络传输系统而言，系统是动态变化的，在流量部署到系统上并开始传输时，没有全局视图，就不能指望全局公平，留下的 gap 是固有的，没法靠算法弥补。，超级经典的一篇论文，我推荐过不止一次，因此我本文不谈异构问题，说点别的，比如拓扑。对，就是要砸，因为我不干了。
代码随想录算法训练营day18|二叉树06
gyuhyhui的博客
09-10 779
示例 2: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 输出: 5 解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。那么我们来说一说，如果 root == q，或者 root == p，说明找到 q p ，则将其返回，这个返回值，后面在中节点的处理过程中会用到，那么中节点的处理逻辑，下面讲解。例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]
mysql统计每月员工补卡次数，月份全显示，当月无补卡记录为0
07-17
要统计每个月份的员工补卡次数，并且确保即使某个月份没有补卡记录也能显示为0，你可以使用MySQL中的日期函数和子查询来实现。以下是一个示例查询： ```sql SELECT months.month, IFNULL(COUNT(t.employee_id), 0) as card_reissue_count FROM ( SELECT 1 as month UNION SELECT 2 UNION SELECT 3 UNION SELECT 4 UNION SELECT 5 UNION SELECT 6 UNION SELECT 7 UNION SELECT 8 UNION SELECT 9 UNION SELECT 10 UNION SELECT 11 UNION SELECT 12 ) as months LEFT JOIN ( SELECT employee_id, MONTH(date_column) as month FROM your_table WHERE reason = '补卡' ) as t ON months.month = t.month GROUP BY months.month; ``` 在这个查询中，我们首先生成了一个包含1到12的月份的子查询，作为月份的基准。然后，我们使用左连接将该子查询与你的表进行连接。内部的子查询将员工ID和补卡日期提取出来，并将日期转换为月份。最后，我们使用 `IFNULL()` 函数来将没有补卡记录的月份的计数结果设置为0。 记得将 "your_table" 替换为你的表名，"date_column" 替换为包含补卡日期的列名，"reason" 替换为补卡原因列的名称。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值