leetcode为了准备面试系列

最新推荐文章于 2025-06-27 16:49:18 发布
原创 最新推荐文章于 2025-06-27 16:49:18 发布 · 1.3k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #算法

博主分享了近期算法练习的心得，包括链表操作、数组处理、二叉树遍历等经典问题的解题思路与代码实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

我的博客就是三天打鱼两天晒网了，最近比较幸运下周六有面试惹，下周六面试要手撕代码，我这个算法渣再抱几天佛脚了，每天刷5题，主要集中在链表、树和数组这三部分，加油鸭！
9.4号5题记录（晚上刚从北京回来，时间不够了，待会寝室要关门了，只写了3题）

19. 删除链表的倒数第N个节点

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

示例：

给定一个链表: 1->2->3->4->5, 和 n = 2.

当删除了倒数第二个节点后，链表变为 1->2->3->5.
说明：

给定的 n 保证是有效的。

进阶：

你能尝试使用一趟扫描实现吗？

解题思路：设置两个指针before和end，先遍历一遍链表求出链表的长度，如果链表长度和n的值相同，就删除头结点，返回新的链表；否则，让end指针先走n+1步，然后before和end都向前走一步，在end到链表尾时，before指的位置为倒数第n个节点
AC代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* before = new ListNode(0);
        ListNode* end = new ListNode(0);
        int len = 1;
        before = head;
        end = head;
        if(head == NULL && n != 0)
            return NULL;
        while(before->next != NULL){
            before = before->next;
            len++;
        }
        if(len == n){
            head = head->next;
            return head;
        }
        else{
            before = head;
            int m = n+1;
            while(m > 0){
                end = end->next;
                m--;
            }
            while(end != NULL){
                before = before->next;
                end = end->next;
            }
            before->next = before->next->next;
        }
        return head;
    }
};

24. 两两交换链表中的节点

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

示例:

给定 1->2->3->4, 你应该返回 2->1->4->3.
说明:

你的算法只能使用常数的额外空间。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

解题思路：要交换链表节点，不能只交换链表值，设置一个dummy节点指向链表头，具体过程看代码了，感觉语言表述不是很清楚，代码就一目了然了

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummy = new ListNode(-1);
        ListNode* pre = dummy;
        dummy->next = head;
        while (pre->next && pre->next->next) {
            ListNode *p = pre->next->next;
            pre->next->next = p->next;
            p->next = pre->next;
            pre->next = p;
            pre = p->next;
        }
        return dummy->next;
    }
};

61. 旋转链表

给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。

示例 1:

输入: 1->2->3->4->5->NULL, k = 2
输出: 4->5->1->2->3->NULL
解释:
向右旋转 1 步: 5->1->2->3->4->NULL
向右旋转 2 步: 4->5->1->2->3->NULL
示例 2:

输入: 0->1->2->NULL, k = 4
输出: 2->0->1->NULL
解释:
向右旋转 1 步: 2->0->1->NULL
向右旋转 2 步: 1->2->0->NULL
向右旋转 3 步: 0->1->2->NULL
向右旋转 4 步: 2->0->1->NULL
解题思路：将链表头尾连起来，然后将头指针向后移动len-k%n的位置，这个位置的下一个位置就是新头部，返回新指针即可。
AC代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(head == NULL)
            return NULL;
        ListNode* p = head;
        int len = 1;
        while(p->next){
            p = p->next;
            len++;
        }
        p->next = head;
   //     int m = (len-k) % len;
        int m = len - k % len;
        while(m--){
            p = p->next;
        }
        ListNode* newhead = p->next;
        p->next = NULL;
        return newhead;
    }
};

注意：刚开始写的时候把len-k%len写成了（len-k）%len，所有len < k的样例都过不了，果然，还是代码能力弱啊，各种坑自己

9.5号答题记录

3. 无重复字符的最长子串

给定一个字符串，找出不含有重复字符的最长子串的长度。

示例 1:

输入: “abcabcbb”
输出: 3
解释: 无重复字符的最长子串是 “abc”，其长度为 3。
示例 2:

输入: “bbbbb”
输出: 1
解释: 无重复字符的最长子串是 “b”，其长度为 1。
示例 3:

输入: “pwwkew”
输出: 3
解释: 无重复字符的最长子串是 “wke”，其长度为 3。请注意，答案必须是一个子串，”pwke” 是一个子序列 而不是子串。
解题思路：解决最长无重复子串问题一般的方法有：1.哈希 2.动态规划
哈希的AC代码，时间复杂度是O(n²)

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if(s.size() == 0)
            return 0;
        unordered_map<char, int> hashmap;
        int count = 1, max = INT_MIN;
        for(int i = 0; i <s.size(); i++){
            hashmap[s[i]]++;
            for(int j = i+1; j < s.size(); j++){
                if(hashmap[s[j]] == 0){
                    hashmap[s[j]]++;
                    count++;
                }
                else{
                    break;
                }
            }
            if(count > max)
                max = count;

            hashmap.clear();
            count = 1;
        }
        return max;
    }
};

4. 两个排序数组的中位数

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2 。

请找出这两个有序数组的中位数。要求算法的时间复杂度为 O(log (m+n)) 。

你可以假设 nums1 和 nums2 不同时为空。

示例 1:

nums1 = [1, 3]
nums2 = [2]

中位数是 2.0
示例 2:

nums1 = [1, 2]
nums2 = [3, 4]

中位数是 (2 + 3)/2 = 2.5
解题思路：这题思路明白了，就是代码还有一些样例没过，调好了再写

23. 合并K个排序链表

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

示例:

输入:
[
1->4->5,
1->3->4,
2->6
]
输出: 1->1->2->3->4->4->5->6
解题思路：使用小根堆，使用优先队列来维护小根堆，思路没什么绕的，还是看基本代码能力
AC代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
struct cmp{
    bool operator()(ListNode* a, ListNode* b){
        return a->val > b->val;
    }
};


class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        priority_queue<int, vector<ListNode*>, cmp> Heap;
        for(int i =0 ; i < lists.size(); i++){
            if(lists[i] != NULL){
                Heap.push(lists[i]);
            }
        }
        ListNode* newhead = NULL;
        ListNode* p = NULL;
        ListNode* q = NULL;
        while (!Heap.empty()) {
            q = Heap.top();
            Heap.pop();
            if(q == NULL)
                return NULL;
            if(q->next != NULL)
                Heap.push(q->next);
            if(newhead == NULL){
                newhead = q;
                p = q;
            }
            else{
                p->next = q;
                p = p->next;
            }
        }
        return newhead;
    }
};

94. 二叉树的中序遍历

给定一个二叉树，返回它的中序 遍历。

示例:

输入: [1,null,2,3]
1
\
2
/
3

输出: [1,3,2]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？
迭代思路：将根节点以及所有的左孩子节点都放入栈中，如果当前节点没有左孩子节点，就从栈中弹出当前节点，并将当前节点的右孩子节点入栈，直到树的所有节点都入栈或栈为空，停止

AC代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*>s;
        vector<int>res;
        if(root == NULL)
            return res;
        TreeNode *p = root;
        while (p || !s.empty()) {
            if(p){
                s.push(p);
                p = p->left;
            }
            else{
                p = s.top();
                res.push_back(p->val);
                s.pop();
                p = p->right;
            }
        }
        return res;
    }
};

199. 二叉树的右视图

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

示例:

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

1 <—
/ \
2 3 <—
\ \
5 4 <—

解题思路：这时想了5分钟的一个思路，情况没考虑全，就想着从节点右子树开始访问，如果当前节点没有右子树，则访问该节点左节点，再从访问右节点，这样做有种情况没考虑到，就是
1 <—
/ \
2 3 <—
/
4
正确结果是[1,2,4],可是按照上述思路只能找到[1,3],明天再写了。
贴一个没AC的代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        TreeNode *p = root;
        vector<int>res;
        while(p){
            res.push_back(p->val);
            if(p->right){
                p = p->right;
            }
            else
                p = p->left;
        }
        return res;
    }
};

9.5号勉强写了够5题，明天继续加油！
9.6号答题记录：

二叉树右视图

借鉴了其他人的博客有了正确思路：右视图就是输出每一层最后一个节点，只要层次遍历，标记每一层最后一个节点输出即可。核心问题是如何标记每一层最后一个节点，thislevelremained:表示当前层剩余的节点数，当节点数为1时，就将节点存入结果数组，每次从队列中弹出元素时，thislevelremained- -；nextlevelhas:表示下一层新入队的节点数，每次有元素入队时，nextlevelhas++。
AC代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        TreeNode *p = root;
        queue<TreeNode*> que;
        vector<int> res;
        if(root == NULL)
            return res;
        que.push(root);
        int thislevellast = 1, nextlevelhas = 0;
    //    cout<<que.front()->val<<endl;
        while (!que.empty()) {
          //  cout<<que.front()->val<<endl;
            TreeNode* tmp = que.front();
            if(thislevellast == 1){
                res.push_back(tmp->val);
            }
            que.pop();
            thislevellast--;
            if(tmp->left != NULL){
                nextlevelhas++;
                que.push(tmp->left);

            }
            if(tmp->right != NULL){
                nextlevelhas++;
                que.push(tmp->right);
            }
            if(thislevellast == 0){
                thislevellast = nextlevelhas;
                nextlevelhas = 0;
            }
        }
        return res;
    }
};

215. 数组中的第K个最大元素

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

示例 1:

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5
示例 2:

输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4
说明:

你可以假设 k 总是有效的，且 1 ≤ k ≤ 数组的长度。
解题思路：使用堆，用优先队列，排序求出第k个最大值
AC代码：

struct cmp {
    bool operator()(int a, int b){
        return a < b;
    }
};
class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        int ans;
        priority_queue<int, vector<int>, cmp>pq;
        for(int i = 0; i < nums.size(); i++){
            pq.push(nums[i]);
        }
        while (k > 0) {
            int t = pq.top();
            pq.pop();
            if(k == 1)
                ans = t;
            k--;
        }
        return ans;
    }
};

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

给出一个完全二叉树，求出该树的节点个数。

说明：

完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

示例:

输入:
1
/ \
2 3
/ \ /
4 5 6

输出: 6
解题思路1：一开始想的就直接用递归，结果超时
递归代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int countNodes(TreeNode* root) {
        if(root == NULL)
            return 0;
        return countNodes(root->left) + countNodes(root->right)+1;
    }
};

解题思路2：用非递归的先序遍历来求完全二叉树中的节点数,依然TLE，所以接下来其他遍历方法应该也不行，只能另换思路了。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int countNodes(TreeNode* root) {
        stack<TreeNode*>s;
        TreeNode* p = root;
        s.push(p);
        int count = 0;
        if(root == NULL)
            return 0;
        while (!s.empty()) {
            TreeNode* tmp = s.top();
            s.pop();
            count++;
            if(tmp->right != NULL){
                s.push(tmp->right);
            }
            if(tmp->left != NULL){
                s.push(tmp->left);
            }
        }
        return count;
    }
};

240. 搜索二维矩阵 II

编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性：

每行的元素从左到右升序排列。
每列的元素从上到下升序排列。
示例:

现有矩阵 matrix 如下：

[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。

给定 target = 20，返回 false。
解题思路：题目要求效率高，所以直接遍历是不行的，一种高效的思路是从矩阵右上角的值开始查找，如果右上角的值大于target，整个最右一列就可以排除。如果右上角的值小于target，从这个列开始按行查找。
AC代码：

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        if(matrix.empty() || matrix[0].empty())
            return false;
        int row = matrix.size();
        int col = matrix[0].size();
        for(int j = col-1; j >= 0; j--){
            if(matrix[0][j] < target){
                int l = 0, r = row-1;
                while (l <= r) {
                    int mid =(l+r)/2;
                    if(matrix[mid][j] == target){
                        return true;
                    }
                    else if(matrix[mid][j] > target){
                        r = mid-1;
                    }
                    else
                        l = mid+1;
                }
            }
            else if(matrix[0][j] == target)
                return true;
        }
        return false;
    }
};
Leetcode面试高频题分类刷题总结
u012333203的博客
02-03 1293
面试中最常考的（分类的稍微有点粗糙了，没有细分出回溯/分治来，准备找个时间给每个DFS的题标记下是哪种DFS）注意：后两题是与快速排序非常相似的快速选择（Quick Select）算法，面试中很常考。以下8个门类是面试中最常考的算法与数据结构知识点。和链表反转几乎是所有链表类问题的基础，尤其是。，代码很短，建议直接背熟。
LeetCode，牛客面试必刷，看了这些，我把这几年大厂面试套路总结出来了！
Android725的博客
09-25 1008
前言 小编是一枚Android开发6年的老菜皮，面试必刷LeetCode，牛客，应该是所有程序员都了解的事情。但是你们有没有发现大厂面试出题，都有自己 特点的套路！！！ 接下来我就给大家说说，我在刷牛客的时候，这么多年总结的一些经验！ 一、BAT等大厂面试问题套路总结 我们先来看看各个大厂面试答题流程 阿里巴巴 腾讯 百度 小米 看上面的面试题，都是牛客网里随便搜的，我用红色圈出来的，都是大厂面试时，最喜欢问的Android知识点，几乎每家大厂必问！ 面试，开始： 1.自我介绍 2.计算机网络
LeetCode上经典面试问题Java语言实现
12-21
这是个人搜集的LeetCode上一些经典面试问题的Java语言实现，涉及数组、链表、堆栈、队列、二叉树、并查集、字典树等15个维度，供各位学习参考使用！
我的面试准备过程--LeetCode(更新中)
weixin_33757911的博客
06-18 98
斐波那契数 public long fibonacci(int n){ int[] res = {0, 1}; if(n < 2){ return res[n]; } long fibNMinusOne = 1; long fibNMinusTwo = 0; ...
LeetCode编程挑战与面试准备题库实战
最新发布
weixin_32456485的博客
06-27 447
LeetCode是广受开发者欢迎的在线编程平台，专注于帮助程序员通过练习题和实际案例提升编程和算法技能。它提供了从基础到高级的一系列编程问题，适用于不同水平的开发者。
算法岗面试准备LeetCode刷题专栏
excellent_sun的博客
09-29 6829
LeetCode刷题专栏LeetCode 21 合并两个有序链表图解code1code2 LeetCode 21 合并两个有序链表 图解 code1 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x)...
Leetcode前提准备
小天花藏
07-03 459
刷LeetCode是我们提升算法比较好的途径。而LeetCode的编辑器并没有我们平时开发中用的编辑器那么强大，编译器强大的功能也让我们失去对api拼写传参上渐渐模糊，而在LeetCode很可能因为Api不熟悉导致编译报错，延长了我们解题的总时间。这里为准备刷LeetCode的小伙伴准备了一些算法中Api:要注意泛型Queue是个接口，不能直接创建，不过我们平时使用的LinkedList就是它的实现类，因此在需要使用队列的时候可以直接使用LinkedListMath是可以直接使用的，不需要导包，但一般也只是
学习 LeetCode 前的准备工作
小羊子的技术专栏
07-04 966
最近决定重学数据结构与算法，同时结合LeetCode实践来刻意练习。持续专注不变的底层知识。
Leetcode:解决了一系列Leetcode问题，为面试编码做准备
03-20
解决了一系列Leetcode问题，为面试编码做准备。它还可以帮助我提高解决问题的能力，并获得更敏锐的分析思维来解决问题。 我尝试在第一次尝试时尽快解决问题。之后，我将代码重构以确保其可读性和优雅性。为了确保我...
leetcode:解决面试问题
04-02
在准备面试时，LeetCode 是一个非常有价值的资源，它提供了大量的编程挑战，涵盖了算法和数据结构等核心领域。本文将深入探讨如何利用 LeetCode 解决面试问题，以及如何通过 Python 编程语言来修复和优化代码。 ...
面试技术问题解决方案集-leetCode题解与面试准备
LeetCode是一个广受欢迎的在线编程和面试准备平台，但在某些情况下，尤其是在中国大陆，LeetCode可能会受到网络限制，无法正常访问。针对这种情况，该文件提供了一系列面试谜题的解决方案，这些题目通常会在技术面试...
LeetCode，C++，面试.zip
01-20
在准备C++面试的过程中，了解并熟练掌握C++的基础语法、高级特性以及相关领域的知识是至关重要的。这份名为"LeetCode，C++，面试.zip"的压缩包文件显然是为帮助求职者提升C++编程技能，特别是针对大厂面试而设计的...
Leetcode面试经典150题
qq_45249273的博客
03-14 1964
经典面试题150
Leetcode经典面试题 -- 第2周
u014687517的博客
04-02 495
Leetcode经典面试题 – 第2周 题目来源于Leetcode 报了一个百面机器学习面试的课程 每周都有定时打卡的作业 都是常出现于面试中的题 总结在此，时常温习， 刷题小能手们觉得写的不错可以移步个人主页 (ps:最近忙着笔试面试，更新太少) 1.二分（Leetcode 69） Implement int sqrt(int x). Compute and return the square ...
LeetCode上一道经典的面试题-O（1）实现LRU Cache
热门推荐
hxqneuq2012的专栏
09-30 1万+
你遇到过这个题吗？ 实现一个LRU Cache。要求查询和插入都在O(1) 时间内完成。 遇到过？很正常。 没遇到？早晚会遇到。（鬼脸） 这是LeetCode上一道十分经典的题目，也是非常火的面试题。 原题： Design and implement a data structure for Least Recently Used (LRU) cache. It sho
leetcode面试100道题
aikudexue的博客
04-01 3962
地址： https://leetcode.com/problemset/top-100-liked-questions/?difficulty=Easy done 表示做过了 undone 表示看了思路但是没敲代码 done （1）两数之和——用哈希表做，键存数字，值存位置 done （20）有效的括号——用栈实现 undone （21）合并两个有序链表 21.合并两个有序...
[leetcode] 面试经典 150 题——篇1：数组/字符串
鲁点点的博客
03-13 458
输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3。合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。输入：nums1 = [0], m = 0, nums2 = [1], n = 1。输入：nums1 = [1], m = 1, nums2 = [], n = 0。解释：需要合并 [1,2,3] 和 [2,5,6]。解释：需要合并的数组是 [] 和 [1]。输出：[1,2,2,3,5,6]
摘自leetcode的面试题
qq_36695156的博客
04-19 312
报数 报数序列是一个整数序列，按照其中的整数的顺序进行报数，得到下一个数。其前五项如下： 1. 1 2. 11 3. 21 4. 1211 5. 111221 1被读作"one 1"("一个一") , 即11。11被读作"two 1s"("两个一"）, 即21。21被读作"one 2", "one 1"（"一个二",...
【LeetCode 随笔】面试经典 150 题【中等＋困难】持续更新中。。。
种一棵树，最好的时间是十年前，其次是现在。
06-08 1223
🌈你好呀！我是 山顶风景独好 🎈欢迎踏入我的博客世界，能与您在此邂逅，真是缘分使然！😊 🌸愿您在此停留的每一刻，都沐浴在轻松愉悦的氛围中。 📖这里不仅有丰富的知识和趣味横生的内容等您来探索，更是一个自由交流的平台，期待您留下独特的思考与见解。🌟 🚀让我们一起踏上这段探索与成长的旅程，携手挖掘更多可能，共同进步！💪✨
LeetCode Python解决方案：面试准备指南
该标题还提到了“准备软件工程师面试的指南”，暗示了Leetcode在求职面试，尤其是软件工程师岗位中的重要性。 描述部分详细介绍了这个项目的用途和目的。作者表示，该项目包含了作者在使用Python（2.7版本）解决...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值