Leetcode——链表

最新推荐文章于 2024-07-09 21:06:56 发布
最新推荐文章于 2024-07-09 21:06:56 发布
阅读量193 收藏
点赞数
文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Arashi_5/article/details/113738221
版权

链表

2. 两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例1
解题思路： 给定的两个链表，由于是逆序排列，从链表第一个结点开始是低位。设置一个进位标志，将两链表的结点值用sum依次相加，和大于等于十时需要进位。结果存在另一链表中。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        //ListNode *p=l1,*q=l2;    //链表指针
        ListNode* result=new ListNode();//存放结果的链表头
        ListNode* r=result;
        int sum=0;
        bool carry=false; //进位标志
        //当两链表都不为空时
        while(l1!=NULL||l2!=NULL)
        {
            sum=0;
            //将两链表对应位置的结点值加起来
            if(l1!=NULL)
            {
                sum+=l1->val;
                l1=l1->next;
            }
            if(l2!=NULL)
            {
                sum+=l2->val;
                l2=l2->next;
            }
            //如果上一次相加发现有进位，则sum再加一
            if(carry)
                sum++;
            //将求和得到的结点对10取余后值赋给下一结点
            r->next=new ListNode(sum%10);
            //位置指针向后
            r=r->next;
 			//本次求和后的进位与否标志
            carry=(sum>=10)?true:false;
        }
        //当两链表均为空，而还需要再进位（两数相加后的位数超过原来数的位数）时，再开辟一个新节点
        if(carry)
        {
            r->next=new ListNode(1);
        }
        return result->next;
    }
};

237. 删除链表中的节点

写一个函数来删除单链表中的某个节点，在不给出链表的情况下直接删除这个节点。待删除节点不是尾节点。
在这里插入图片描述
解题思路：

  • 这道题真的非常妙，刚开始看的时候还以为题出错了，怎么少给了参数，没有链表怎么删这个节点。后来又读了几遍搞懂了题意，但是还是不会做啊呜呜呜，看看评论。解法真的很简单很妙，我自己是真的想不到。
  • 要直接删除一个节点，可以将这个节点的值变成他的下一个节点，然后跳过下一个节点。
  • 也就是说成为另一个人，然后再让那个人消失，那么原来的我也就消失了。细思极恐。
  • 两行代码搞定。
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
    	//变成下一个人
        node->val=node->next->val;
        //然后让他消失
        node->next=node->next->next;
    }
};

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

给你一个链表，删除链表的倒数第n个结点，并且返回链表的头结点。
在这里插入图片描述
解法一：计算链表长度

  • 先遍历一次链表，计算长度L，然后再遍历一次到L-n+1的位置，下一个结点就是要删除的，跳过它。
  • 构造一个头结点dummy，接在head的前面，当需要删除首元结点时就可以不用做判断，最终返回dummy的下一个结点指针。
  • 这个方法挺慢的，时间O(L)，空间O(1)
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        int size=0;
        //构造一个头节点
        ListNode * dummy=new ListNode(0,head);
        ListNode *i=head,*j=dummy;
        //第一次遍历，计算链表的大小
        while(i)
        {
            i=i->next;
            size++;
        }
        //第二次，遍历到要删除的倒数第n个结点前面的位置
        for(int c=1;c<size-n+1;c++)
        {
            j=j->next;
        }
        //跳过待删除的那个结点
        j->next=j->next->next;
        ListNode* ans = dummy->next;
        delete dummy;
        return ans;
    }
};

解法二：双指针

  • 利用快慢两个指针，初始时first快指针指向head，慢指针second指向dummy。
  • 快指针先走n步，到达第n个结点，此时快慢指针间相隔n个结点，然后快慢指针开始同时走，直到快指针到达表尾。
  • 慢指针从头开始走，当快指针指向空时，慢指针的下一个结点就是待删除的倒数第n个结点
    在这里插入图片描述
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        //双指针解法
        //先构造一个头结点，其下一结点为head，便于删除第一个结点
        ListNode * dummy=new ListNode(0,head);
        ListNode * first=head,*second=dummy; //first是快指针，second是慢指针
        //i先走n步
        for(int i=0;i<n;i++)
        {
            first=first->next;
        }
        //当快指针走到了头时（first为空），慢指针指向结点的下一个结点就是待删除结点。
        while(first)
        {
            first=first->next;
            second=second->next;
        }
        //跳过倒数第n个结点
        second->next=second->next->next;
        ListNode * ans=dummy->next;
        delete dummy;
        return ans;
    }
};

206. 反转链表

反转一个单链表。
在这里插入图片描述
解法一 迭代
遍历链表，将当前结点i的next域设为它的前一个结点，相当于将箭头转个向。设置之前需要用一个临时结点保存i原本的下一个结点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        //遍历链表，将当前结点的next设为它前面的那个结点
        ListNode * pre=nullptr;
        ListNode * i=head;
        while(i)
        {
        	//保存i原本的下一个结点
            ListNode * next=i->next;
            i->next=pre;
            pre=i;
            i=next;
        }
        return pre;
    }
};

解法二 递归

递归的三条件：

  • 大问题分解成两个问题
  • 子问题的求解方式和大问题一样（将链表分解为首元结点和除首元结点以外的所有节点，然后递归调用）
  • 存在最小子问题（递归终止）
  • 参考
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        //用递归，将原问题分解为首元结点和除首元结点以外结点的子问题
        //终止条件，当递的过程到达子链表只剩一个元素时，直接将其返回
        //因为一个单节点不用进行反转
        if(!head||!head->next)
        {
            return head;
        }
        //递归调用
        ListNode * p=reverseList(head->next);
        head->next->next=head;
        head->next=nullptr;
        //返回的部分已经做好了反转
        return p;
    }
};

21. 合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
l1 和l2均按 非递减顺序 排列
在这里插入图片描述
解法一 暴力遍历

  • 设置一个头结点，然后遍历l1和l2，将值较小的那个结点接在头结点后，然后指向下一结点。
  • 时间O(M+N)，空间O(1)
  • 思路简单，容易理解
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        //用双指针，暴力解法
        ListNode*dummy=new ListNode(0);
        //总链表指针
        ListNode*pre=dummy;
        //遍历两个链表，将较小结点接在总链表后面
        while(l1&&l2)
        {
            if(l1->val<l2->val)
            {
                pre->next=l1;
                pre=l1;
                l1=l1->next;
            }
            else
            {
                pre->next=l2;
                pre=l2;
                l2=l2->next;
            }
        }
        //当有一方到达表尾时，将将另一个表的剩余部分全部接在总链表之后
        if(l1)
            pre->next=l1;
        if(l2)
            pre->next=l2;
        ListNode*ans=dummy->next;
        delete dummy;
        return ans;
    }
};

解法二 递归

  • 合并l1和l2，先看l1和l2的首元结点哪个更小
  • 然后较小结点的next指针指向其余节点的合并结果（递归调用）
  • 终止条件是两个链表中有一个到达表尾，然后返回另外一个链表所有剩余部分
  • 官方题解
    在这里插入图片描述
  • 时间·O(M+N)·，空间·O(M+N)·，·M·和·N·是两个链表的长度
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        //递归解法
        //判断 l1 和 l2 头结点哪个更小，然后较小结点的 next 指针指向其余结点的合并结果。（调用递归）
        //终止条件
        if(!l1)
            return l2;
        if(!l2)
            return l1;
        if(l1->val<=l2->val)
        {
           	//递归调用
            l1->next=mergeTwoLists(l1->next,l2);
            return l1;
        }
        l2->next=mergeTwoLists(l1,l2->next);
        return l2;
    }
};

234. 回文链表

请判断一个链表是否为回文链表。
用 O(n) 时间复杂度和 O(1)空间复杂度解决此题
在这里插入图片描述
解题思路： （来自官方题解）

  • 将链表后半部分反转（会修改链表结构），将前半部分和后半部分进行比较，比较后将链表恢复原样。
  • 分成五个步骤
  1. 找到前半部分链表的尾节点。我们也可以使用快慢指针在一次遍历中找到：慢指针一次走一步，快指针一次走两步，快慢指针同时出发。当快指针移动到链表的末尾时，慢指针恰好到链表的中间。通过慢指针将链表分为两部分。若链表有奇数个节点，则中间的节点应该看作是前半部分。
  2. 反转后半部分链表。可以使用「206. 反转链表」问题中的解决方法来反转链表的后半部分。
  3. 判断是否回文。比较两个部分的值，当后半部分到达末尾则比较完成，可以忽略计数情况中的中间节点。
  4. 恢复链表。与步骤二使用的函数相同，再反转一次恢复链表本身。
  5. 返回结果。
    代码
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        //快慢指针
        ListNode * fast=head;
        ListNode * slow=head;
        while(fast->next&&fast->next->next)
        {
            fast=fast->next->next;
            slow=slow->next;
        }
        //快指针到达表尾时退出
        //翻转后半段链表
        ListNode * p=reverseList(slow->next);
        ListNode * q=head;
        ListNode * second_half=p;
        //逐个比较前半段和后半段子链表
        //ListNode * temp=fast;
        while(p)
        {
            if(p->val==q->val)
            {
                p=p->next;
                q=q->next;
            }
            else
                return false;
        }
        //还原链表
        slow->next=reverseList(second_half);
        return true;
    }
    ListNode* reverseList(ListNode* head) {
        //用递归，将原问题分解为首元结点和除首元结点以外结点的子问题
        //终止条件，当递的过程到达子链表只剩一个元素时，直接将其返回
        //因为一个单节点不用进行反转
        if(!head||!head->next)
        {
            return head;
        }
        //递归调用
        ListNode * p=reverseList(head->next);
        head->next->next=head;
        head->next=nullptr;
        return p;
    }
};
ninomiya33
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
php-leetcode题解之链表的中间结点.zip
06-10
本话题聚焦于一个特定的题目——找到链表的中间节点，这是链表数据结构中常见的问题，对于理解和掌握链表操作至关重要。我们将详细探讨这个问题以及如何用PHP来解决它。 链表是一种线性数据结构，它不像数组那样...
leetcode：移除链表元素 python解法
12-21
在LeetCode上，有一道经典的链表操作问题——移除链表元素。这个问题要求我们从给定的单链表中删除所有值等于`val`的节点。本文将深入解析问题的解决方案，并提供一种使用Python实现的方法。 ### 1. 题目说明 题目...
LeetCode----ListNode语法及基本操作
qq_41142785的博客
04-17 8246
ListNode相关要点 前言 最近在刷LeetCode，遇到一些似曾相识但又模棱两可的知识点，这里做一下总结，本文是Java中ListNode语法及操作的梳理。 类结构如下 public class ListNode { int val; //结点值 ListNode next; //用来指向下一个结点的ListNode对象 ListNode() {} ListNode(int val) { this.val = val; } ListNode(int val, ListNod
【经典全解】链表ListNode、new ListNode(x)的定义，取值，赋值
热门推荐
CodingLJ
11-30 1万+
一、ListNode的定义 先看下链表的结构，有链表的值域，指针域，和链表赋值的方法。 public class ListNode{ // 链表的某个值 int val; // 链表指针指向的是下一个元素 ListNode next; // ListNode 赋值方法 ListNode(int x){val = x}; } 注意事项： 1.定义链表 定义链表的时候，当x的值为0的...
Leetcode热题Hot100-链表题综合
weixin_42127177的博客
11-09 1264
2-两数相加 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。 提示： 每个链表的节点数在范围[1,100]内 0<=Node.val<=9 题目数据保证列表表示的数字不含前导零 解题思路 由于输入的两个链表都是逆序存储数字的位数的，因此两个链表中同一位置的数字可以直接相加。 我们同时遍历两个链表，逐位计算
删除链表中倒数第n个节点
兔清风的博客
10-02 576
容易 删除链表中倒数第n个节点 28% 通过 给定一个链表，删除链表中倒数第n个节点，返回链表的头节点。 您在真实的面试中是否遇到过这个题？  Yes 样例 给出链表1->2->3->4->5->null和 n = 2. 删除倒数第二个节点之后，这个链表将变成1->2->3->5->null. 注意 链表中的节点个数大于等
LeetCode解题心得——反转链表（python）
12-21
在LeetCode中，反转链表是一个常见的数据结构问题，它主要考察了对链表操作的理解以及递归或迭代解决问题的能力。本题的目标是反转给定的单链表，例如，对于输入1->2->3->4->5->NULL，期望得到的输出是5->4->3->2->1...
php-leetcode题解之两两交换链表中的节点.zip
06-10
在本压缩包“php-leetcode题解之两两交换链表中的节点.zip”中，包含的是关于使用PHP解决LeetCode算法题目的一个实例——“两两交换链表中的节点”。这个题目是LeetCode上的经典链表操作问题，旨在锻炼开发者对链表...
java-leetcode题解之第61题旋转链表.zip
06-05
【标题】：“java-leetcode题解之第61题旋转链表.zip”指向的是一个Java实现的LeetCode问题解决方案，具体是第61题——旋转链表。LeetCode是一个在线平台，提供各种编程题目，帮助程序员提升算法技能和解决实际问题...
leetcode 链表（删除节点、反转、合并、回文、环形）
FixTheCoder
08-06 398
删除链表中的节点 请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。 现有一个链表 -- head = [4,5,1,9]，它可以表示为: 4 -&gt; 5 -&gt; 1 -&gt; 9 示例 1: 输入: head = [4,5,1,9], node = 5 输出: [4,1,9] 解释: 给定你链表中值为 5 的第二个节点，...
剑指 Offer 22. 链表中倒数第k个节点
qq_38419093的博客
04-12 54
题目 输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。 例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。 解题思路（官方） fast先后移k次,当fast为空时,按链表顺序 slow的后边 有k个(第k个为空) 所以从1开始计数,从后往前第k个是slow。 public ListNode getKthFromEnd(ListNode head, int k)
面试题15：链表中倒数第K个结点
weixin_34018169的博客
04-27 86
题目：输入一个链表，输出该链表中倒数第K个结点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾结点是倒数第1个结点。例如一个链表有6个结点，从头结点开始它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个结点是值为4的结点。 看到这道题目，最直观的想法，就是先算出链表的长度n，然后倒数第k个结点就是顺序的第(n-k+1)个数，不过这样需要2次遍历链表，如果要求只能遍历链表一次...
LeetCode19----删除链表的倒数第N个节点
aier0323305的博客
05-26 133
给定一个链表，删除链表的倒数第n个节点，并且返回链表的头结点。 示例： 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后，链表变为 1->2->3->5. 说明： 给定的n保证是有效的。 进阶： 你能尝试使用一趟扫描实现吗？ 因为链表的节点只有next指针，并且我...
双指针算法5.4
FlowerCA的博客
05-05 96
回文链表 给定一个链表的头结点 head，判断链表删除一个节点后是否可以成为「回文链表」。 若可以，则返回 true；否则返回 false 注意： 输入用例均保证链表长度 大于等于 3 示例 1： 输入：head = [1,2,2,3,1] 输出：true 解释：如下图所示，蓝色结点为删除的结点 删除该节点后，链表为「回文链表」 [1,2,2,1]，返回 true 首先把链表取出换成更好处理的数据结构 初步想法是对每个节点遍历尝试删除，再判断删除之后的表是不是回文。这样处理的复杂.
leetCode--234.回文链表（利用删除链表倒数第K个节点、反转链表思路解题）
GTZ_0724的博客
04-02 285
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 回文链表的判断题目内容一、题目解读链表的特殊性二、使用步骤1.引入库2.读入数据总结 题目内容 回文链表:题目链接 请判断一个链表是否为回文链表。 **示例 1**: 输入: 1->2 输出: false **示例 2**: 输入: 1->2->2->1 输出: true **进阶**： 你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？ 一、题目解读 我们
Leetcode.2链表之删除重复节点判断回文
qq_44953371的博客
03-16 102
2+3/删除链表中的重复结点、判断回文链表 本来今天是想单独看看递归的，由于人太暴躁就继续做了简单的链表题。 2/给定一个排序链表，删除所有重复的元素使其只留其中之一。 这道题让我实实在在有感受到递归的魅力，我真的是太怕递归了，总感觉脑袋转不过那么多次。今天突然发现我把递归次数降下来先验证代码会比较好一些。主要是在另外一道题里面又发现这种递归删除节点的方法，所以在这里也试了一下。 /** * Definition for singly-linked list. * struct ListNode {
链表中倒数第K个节点（转自leetcode）
qq_29541407的博客
04-09 82
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。 例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。 示例： 给定一个链表: 1->2->3->4->5, 和 k = 2. 返回链表 4->5. 通过次数152,237提交次数193,543 来源：力扣（LeetCode） 链接：https://leetcode-c.
数据结构和算法（0-1）----递归
最新发布
yanminghe66666的博客
07-09 633
递归算法，爬楼梯等解法
rust leetcode 链表
05-10
Rust 是一种现代的编程语言，特别适合处理内存安全和线程安全的代码。在 LeetCode 中，链表是经常出现的题目练习类型，Rust 语言也是一种非常适合处理链表的语言。接下来，本文将从 Rust 语言的特点、链表的定义和操作，以及 Rust 在 LeetCode 中链表题目的练习等几个方面进行介绍和讲解。 Rust 语言的特点： Rust 是一种现代化的高性能、系统级、功能强大的编程语言，旨在提高软件的可靠性和安全性。Rust 语言具有如下几个特点： 1. 内存安全性：Rust 语言支持内存安全性和原语级的并发，可以有效地预防内存泄漏，空悬指针以及数据竞争等问题，保证程序的稳定性和可靠性。 2. 高性能：Rust 语言采用了“零成本抽象化”的设计思想，具有 C/C++ 等传统高性能语言的速度和效率。 3. 静态类型检查：Rust 语言支持静态类型检查，可以在编译时检查类型错误，避免一些运行时错误。 链表的定义和操作： 链表是一种数据结构，由一个个节点组成，每个节点保存着数据，并指向下一个节点。链表的定义和操作如下： 1. 定义：链表是由节点组成的数据结构，每个节点包含一个数据元素和一个指向下一个节点的指针。 2. 操作：链表的常用操作包括插入、删除、查找等，其中，插入操作主要包括在链表首尾插入节点和在指定位置插入节点等，删除操作主要包括删除链表首尾节点和删除指定位置节点等，查找操作主要包括根据数据元素查找节点和根据指针查找节点等。 Rust 在 LeetCode 中链表题目的练习： 在 LeetCode 中，链表是常见的题目类型，而 Rust 语言也是一个非常适合练习链表题目的语言。在 Rust 中，我们可以定义结构体表示链表的节点，使用指针表示节点的指向关系，然后实现各种操作函数来处理链表操作。 例如，针对 LeetCode 中的链表题目，我们可以用 Rust 语言来编写解法，例如，反转链表，合并两个有序链表，删除链表中的重复元素等等，这样可以更好地熟悉 Rust 语言的使用和链表的操作，提高算法和编程能力。 总之，在 Rust 中处理链表是非常方便和高效的，而 LeetCode 中的练习也是一个非常好的机会，让我们更好地掌握 Rust 语言和链表数据结构的知识。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值