LeetCode链表题经典题目（一）

最新推荐文章于 2022-11-17 17:08:29 发布
最新推荐文章于 2022-11-17 17:08:29 发布
阅读量180 收藏 1
点赞数
分类专栏： # 算法 文章标签： 链表 leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43478694/article/details/124458644
版权

文章目录

147. 对链表进行插入排序

(https://leetcode-cn.com/problems/insertion-sort-list/)
image-20220316151215046

  1. 当前节点和前面的节点构成有序：

image-20220316151624479

  1. 当前节点和前面的节点构成无序，需要移动，从链表头部往后寻找（数组一般是从后往前寻找）：

image-20220316152253152

class Solution {
    public ListNode insertionSortList(ListNode head) {
        if(head==null)
            return null;
        ListNode  dummy=new ListNode(-1);
        dummy.next=head;
        ListNode lastSorted=head,cur=head.next;
      
        while(cur!=null)
        {
          if(lastSorted.val<=cur.val)//当前节点和前面的节点已经构成有序
          {
              lastSorted=lastSorted.next;
          }
          else
          {
              ListNode pre=dummy;
              while(pre.next.val<=cur.val)
                pre=pre.next;//pre指向第一个大于cur的节点的前一个节点
            lastSorted.next=cur.next;
            cur.next=pre.next;
            pre.next=cur;
          }
          cur=lastSorted.next;//cur指向下个未排序的节点


        }
        return dummy.next;

    }
}
//O(n^2)
//O(1)

2. 两数相加

https://leetcode-cn.com/problems/add-two-numbers/
image-20220320092705138

思路：对链表进行加法操作，从两条链表的头结点开始，将对应的节点值相加并求进位，由于两条链表的长度可能不一样，所以当遍历完某条链表时，可以用0值来代替不存在的节点，方便计算，注意的一点时，如果最后的进位不为0，说明最高位有进位，需要额外添加1个值为1的节点，比如1+9 返回01

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode dummy=new ListNode();
        ListNode cur=dummy;
        int sum=0,carry=0;
        while(l1!=null||l2!=null)
        {
           int num1=l1==null?0:l1.val;
           int num2=l2==null?0:l2.val;
           sum=num1+num2+carry;
           carry=sum/10;
           sum%=10;
           cur.next=new ListNode(sum);
           cur=cur.next;
           if(l1!=null)
                l1=l1.next;
            if(l2!=null)
                l2=l2.next;

        }
        if(carry!=0)//最后的进位不要忘记
            cur.next=new ListNode(1);
        return dummy.next;

    }
   
}
//O(max(m,n))  m n分别为两个链表的长度
//O(1)

21. 合并两个有序链表

(https://leetcode-cn.com/problems/merge-two-sorted-lists/)
image-20220321085708539

思路：向合并两个有序数组一样，同时从头遍历两条链表，比较当前的两个节点的值，取较小的值，并将较小的值所在链表的对应指针往后移动一次；当有某条链表提前遍历完时，只需要将剩余的节点直接连到答案节点上即可，无需再次遍历

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode dummy=new ListNode();
        ListNode cur=dummy;
        while(list1!=null&&list2!=null)
        {
           if(list1.val<=list2.val)
           {
               cur.next=list1;
               list1=list1.next;
           }
           else 
           {
               cur.next=list2;
               list2=list2.next;
           }
           cur=cur.next;
            
        }
        if(list1!=null)
            cur.next=list1;
        if(list2!=null)
            cur.next=list2;
        return dummy.next;

    }
}
//O(n)
//O(1)

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

(https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/)
image-20220323095923417

思路：使用快慢指针，先让快指针走n步，然后快慢指针一起走，这样当快指针走到最后一个节点时，慢指针刚好走到待删除节点的前一个节点； 注意：为了避免删除的节点是头结点这种情况，建议使用dummy节点，避免发生空指针异常

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy=new ListNode();
        dummy.next=head;
        ListNode slow=dummy,fast=dummy;
        for(int i=1;i<=n;i++)
            fast=fast.next;
        while(fast.next!=null)//快指针是否到达最后一个节点？
        {
            slow=slow.next;
            fast=fast.next;
        }
        slow.next=slow.next.next;//删除节点
        return dummy.next;//返回 注意返回的不是head  因为待删除的节点就是head节点
    }
}
//O(n)
//O(1)

141. 环形链表

(https://leetcode-cn.com/problems/linked-list-cycle/)
image-20220325101929430

思路：假设链表中有环，可以将这个环想象成1个环形跑道，如果有两个人在跑道上跑步，一个跑的快，一个跑的慢，假设跑的快的速度是跑的慢的速度的两倍，那么快的人一定可以在一圈内追上慢的人

简单来说：如果有环的话，快慢指针可以相遇

public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode slow=head,fast=head;
        while(fast!=null&&fast.next!=null)
        {
            fast=fast.next.next;
            slow=slow.next;
            if(fast==null||slow==null)//到达null 说明没有环
                return false;
            if(fast==slow)//fast追上slow说明有环
                return true;
        }
        return false;//无环
    }
}
//O(n)
//O(1)

142. 环形链表 II

(https://leetcode-cn.com/problems/linked-list-cycle-ii/)

在这里插入图片描述

思路：先根据141题的思路判断链表是否存在环，即使用快慢指针，快指针的速度是慢指针的2倍，当相遇时，假设慢指针走了k步，则快指针走了2k步，由于二者最后位置相同，所以快指针多走的k步实际上就环的长度的整数倍（类似于操场跑步，可能多跑了1圈，也可能多跑了2圈）；假设入环点到相遇点的距离是m,则起点到入环点的距离是k-m, 而从相遇点再走到入环点的距离也是k-m, 因此相遇后，让一个节点从起点开始走，一个节点从相遇点开始走，此时速度一样，则再次相遇时，相遇点就是入环点
在这里插入图片描述

public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head==null)
            return null;
        ListNode fast=head,slow=head;
        boolean hasCircle=false;
        while(fast!=null&&fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;
            if(fast==null||slow==null){//等于null说明没有环
                return null;
            }
            if(fast==slow){//存在环 退出循环开始后面找环的入口
                hasCircle=true;
                break;
            }
        }
        if(!hasCircle)
            return null;
        fast=head;//一个指向头节点
        while(fast!=slow){//再次相遇的地方就是入环口
            fast=fast.next;
            slow=slow.next;   
        }
        return fast;
    }
}
//O(n)
//O(1)

206. 反转链表

(https://leetcode-cn.com/problems/reverse-linked-list/)
image-20220330083000695

思路1：迭代

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre=null,cur=head;
        while(cur!=null)
        {
            //顶针式写法
            ListNode tmp=cur.next;
            cur.next=pre;
            pre=cur;
            cur=tmp;
        }
        return pre;//最后返回pre
    }
}
//O(n)
//O(1)

思路2：递归

class Solution {
    public ListNode reverseList(ListNode head) {
       if(head==null||head.next==null)
            return head;
        ListNode newHead=reverseList(head.next);//反转后n-1个节点得到的头结点
        head.next.next=head;//比如1->2->3->4->5  后面4个节点已经反转得到1->2<-3<-4<-5
        //现在需要2步操作  2.next=1  1.next=null  其中2=1.next  1是当前的旧head 
        head.next=null;
        return newHead;
    }
}
//O(n)
//O(n)

23. 合并K个升序链表

(https://leetcode-cn.com/problems/merge-k-sorted-lists/)
在这里插入图片描述

思路1：优先级队列，先将每个链表的头节点加入优先级队列中，然后取出队首的节点就是最小的，假设取出的节点是node,然后判断node后面还有没有节点，如果有则将node的下一个节点也加入队列，开始下一轮的选取，直到最后队列为空

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        PriorityQueue<ListNode> pq=new PriorityQueue<>((a,b)->a.val-b.val);
        for(ListNode head:lists){
            if(head!=null){
                pq.offer(head);
            }
        }
        ListNode dummy=new ListNode(),p=dummy;
        while(!pq.isEmpty()){
            ListNode node=pq.poll();
            p.next=node;
            p=p.next;
            if(node.next!=null){
                pq.offer(node.next);
            }
        }
        return dummy.next;
    }
}
//(kn*logk)  最多有kn个节点 每个节点入队出队的时间logk
//O(k) 队列中的元素最多不会超过k个

思路2：根据合并两条有序链表的基础，将k条链表分治处理

在这里插入图片描述

如上图所示，划分到最小的子问题后，6条链表两两合并变成3条，然后在合并变成2条，最后变成1条，即最终的答案；假设每条链表的长度为n

第一轮合并: k 2 \frac{k}{2} 2k​组 每组的节点数: n × 2 n\times 2 n×2 ---->nk

第二轮合并: k 4 \frac{k}{4} 4k​组 每组的节点数: n × 4 n\times 4 n×4—>nk

第三轮合并: k 8 \frac{k}{8} 8k​组 每组的节点数: n × 8 n \times 8 n×8—>nk

…

即每一层都需要nk次操作，一共有 l o g k log k logk层，故时间复杂度为: n k × l o g k nk\times logk nk×logk

空间复杂度为递归消耗的空间: l o g k log k logk

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        return merge(lists,0,lists.length-1);
    }
    public ListNode merge(ListNode[] lists,int left,int right){
        if(left==right){
            return lists[left];
        }
        if(left>right){
            return null;
        }
        int mid=(left+right)>>1;
        return mergeTwoLists(merge(lists,left,mid),merge(lists,mid+1,right));
    }
    //合并两条有序的链表的模板方法
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode dummy=new ListNode();
        ListNode cur=dummy;
        while(list1!=null&&list2!=null)
        {
           if(list1.val<=list2.val)
           {
               cur.next=list1;
               list1=list1.next;
           }
           else 
           {
               cur.next=list2;
               list2=list2.next;
           }
           cur=cur.next;
            
        }
        if(list1!=null)
            cur.next=list1;
        if(list2!=null)
            cur.next=list2;
        return dummy.next;

    }
}

25. K 个一组翻转链表

(https://leetcode-cn.com/problems/reverse-nodes-in-k-group/)

在这里插入图片描述

思路：需要定义两个函数

ListNode getKthNode(ListNode cur,int k): 求以cur开始往后的第k个节点

boolean hasKNodes(ListNode cur,int k): 判断以cur开始的链表是否含有k个节点

cur先指向头节点，判断以cur开始的链表是否含有k个节点，没有直接返回，有的话进行反转

对于某一组（有K个节点），该组的第K个节点反转后会成为该组的头节点，该组的原来的头节点反转后会成为该组的最后一个节点，注意：反转后的最后一个节点应该指向下一组的第一个节点（下一组不足K个 未反转）或者指向下一组的最后一个节点（下一组足k个 可以反转），因此反转某组后，使该组反转后的最后一个节点指向下一组的第一个或最后一个节点

public ListNode reverseKGroup(ListNode head, int k) {
         if(k==0||k==1)//0个1组或1个一组相当于不用反转
            return head;
        ListNode cur=head;
        ListNode newHead=null;
        if(hasKNodes(cur,k))//链表长度>=k
            newHead=getKthNode(cur,k);
        else //链表长度<k 相当于不用反转
            return head;
        ListNode pre=null,tmp;
        while(cur!=null&&hasKNodes(cur, k)){
            int i=0;
            ListNode last=cur;//last保存当前组的第一个节点 反转之后last就是最后1个节点
            while(i<k){//逆置某一组  和单链表的反转代码类似
                tmp=cur.next;
                cur.next=pre;
                pre=cur;
                cur=tmp;
                i++;
            }
            last.next=getKthNode(cur,k);//逆置完后该组原来的第一个节点变成最后一个
            //最后一个节点连接下一组的第k个节点（下一组有k个则和第k个连接  不足就跟第一个节点连接）
            
        }
        return newHead;
    }
    //获取从cur开始往后数的第k个节点
    public ListNode getKthNode(ListNode cur,int k){
        if(cur==null)
            return null;
        int i=1;
        ListNode p=cur,pre=p;
        while(p!=null&&i<k){
            pre=p;
            p=p.next;
            i++;
        }
        return p==null?cur:p;//有k个则返回改组第k个节点  不足k个则返回改组第一个节点
    }
    //以cur节点开始是否还有k个节点？
    public boolean hasKNodes(ListNode cur,int k){
        int i=0;
        while(cur!=null){
            i++;
            if(i==k)
                break;
            cur=cur.next;
        }
        return i==k;
    }
//O(n)
//O(1)

138. 复制带随机指针的链表

https://leetcode-cn.com/problems/copy-list-with-random-pointer/
在这里插入图片描述

先根据已有节点的值创建一个具有相同值的节点，建立原有节点和新节点的映射，先不考虑next和random指针创建完映射之后，对于原始节点X，对应的新创建的节点Y=map.get(X) Y.next就是map.get(X.next) Y.random就是map.get(X.random) X.next和X.random都是指向原有的节点，原有的节点是map中的键，因此都对应一个新创建的节点

class Solution {
    HashMap<Node,Node> map;
    public Node copyRandomList(Node head) {
        map=new HashMap<>();
        Node cur=head;
        while(cur!=null){
            map.put(cur,new Node(cur.val));
            cur=cur.next;
        }
        cur=head;
        while(cur!=null){
            Node cloneNode=map.get(cur);
            cloneNode.next=map.get(cur.next);
            cloneNode.random=map.get(cur.random);
            cur=cur.next;
        }
        return map.get(head);
    }
}
//O(n)
//O(n)

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

https://leetcode-cn.com/problems/swap-nodes-in-pairs/
在这里插入图片描述

//迭代
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
       if(head==null||head.next==null)//链表为空或者只有1个节点
            return head;
        ListNode dummy=new ListNode();
        dummy.next=head;
        ListNode tmp=dummy;//创建哑节点 方便操作
        while(tmp.next!=null&&tmp.next.next!=null){//有2个节点
            ListNode node1=tmp.next;
            ListNode node2=tmp.next.next;
            tmp.next=node2;//第2个节点作为头节点
            node1.next=node2.next;//第一个节点指向第3个节点
            node2.next=node1;
            tmp=node1;
        }
        return dummy.next;
    }
    
}
//O(n)
//O(1)

//递归
class Solution {
    public ListNode swapPairs(ListNode head) {
       if(head==null||head.next==null)//链表为空或者只有1个节点
            return head;
        ListNode newHead=head.next;//第2个节点是新的头节点
        head.next=swapPairs(newHead.next);//第1个节点指向第3个节点以后反转后的头节点
        newHead.next=head;//第2个节点指向第1个节点
        return newHead;
    }
    
}
//O(n)
//O(n)

剑指 Offer II 029. 排序的循环链表

https://leetcode.cn/problems/4ueAj6/
在这里插入图片描述

思路：遍历两次链表，第一次遍历找出链表中的最小值节点和最大值节点，第2次遍历找出新加入的节点的待插入位置，然后将新节点插入即可，细节处理见代码注释

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

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _next) {
        val = _val;
        next = _next;
    }
};
*/

class Solution {
    public Node insert(Node head, int insertVal) {
        if(head==null){
            Node newNode=new Node(insertVal);
            newNode.next=newNode;
            return newNode;
        }
        Node pre=head,cur=head.next;
        while(pre.val<=cur.val&&cur!=head){//cur!=head 防止1 1 1这种情况出现死循环
            pre=cur;
            cur=cur.next;
        }
        Node first=cur;
        boolean flag=false;
       //cur指向最小的节点(第一个) pre指向最大的节点(最后一个) 下面的while如果不执行说明
       //insertVal是当前最小的值 直接连在pre后面
        while(cur.val<insertVal){
            pre=cur;
            cur=cur.next;
            //下面的判断防止当insertVal是当前一个比较大的值导致死循环 链表中找不到比其小的值
            //此时遍历一次链表就停止
            if(flag&&cur==first){//第2次cur=first说明遍历一次结束
                break;
            }
            if(!flag){//设置第2次访问标记
                flag=true;
            }
        }
        //cur是newNode的下一个节点 pre是newNode的上一个节点
         Node newNode=new Node(insertVal);
         newNode.next=cur;
         pre.next=newNode;
         return head;
    }
}
//O(n)
//O(1)
CodePanda@GPF
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Leetcode链表题目集合
weixin_44137260的博客
04-29 215
160.Intersection of Two Linked Lists 注意，链表结点相同意味着他们的值相同，下一个结点也相同 方法1：暴力法 方法2： /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode...
leetcode链表相关经典习题:
zhangpupu320的博客
03-31 198
1.给定一个链表，判断链表中是否有环。 /** Definition for singly-linked list. class ListNode { int val; ListNode next; ListNode(int x) { val = x; next = null; } } / public class Solution { pub...
LeetCode和牛客网经典链表题目合集
m0_70811813的博客
11-17 486
移除链表元素、反转链表、链表的中点节点、链表中倒数最后k个节点、合并两个有序链表、分割链表、链表的回文结构、相交链表、环形链表、环形链表II、复制带随机指针的链表
Leetcode：链表刷题（7道经典题目）
一起加油~
03-22 1644
Leetcode：链表刷题 列出了一些关于链表的经典题目，并提供了对应的题解。主要是用C++实现的。对于使用其他语言的童鞋，可以很好的迁移过去。
iOS LeetCode ☞ 旋转链表
HumorousGhost
05-11 211
给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。 示例 1： 输入：head = [1,2,3,4,5], k = 2 输出：[4,5,1,2,3] 示例 2： 输入：head = [0,1,2], k = 4 输出：[2,0,1] 提示： 链表中节点的数目在范围 [0, 500] 内 -100 <= Node.val <= 100 0 <= k <= 2 * 109 解题思路 记给定链表的长度为 n，注意到当向右移动的次数 k ≥ n 时
leetcode算法题-链表操作（两数相加）
12-20
在LeetCode上，有一道经典的算法题，名为“两数相加”（Add Two Numbers）。题目要求使用两个非空的链表来表示两个非负整数，这些整数的每一位都是逆序存储的，即链表的头部表示最高位。每个链表节点仅能存储一个...
leetcode经典题目全解析
05-27
《LeetCode经典题目全解析》是一份由编程高手精心编撰的文档，旨在全面解析LeetCode平台上众多的算法挑战题目。LeetCode作为一个知名的在线编程练习平台，汇集了各种难度级别的编程题目，涵盖数据结构、算法、设计...
leetcode：移除链表元素 python解法
12-21
在LeetCode上，有一道经典的链表操作问题——移除链表元素。这个问题要求我们从给定的单链表中删除所有值等于`val`的节点。本文将深入解析问题的解决方案，并提供一种使用Python实现的方法。 ### 1. 题目说明 题目...
leetcode中国-LeetCode:LeetCode经典题目分类汇总(JavaScript实现)
06-29
和力扣中国的每日一题，如果有共同刷题的小伙伴可以点击 一起参与。 我对题目进行了标签分类，你也可以按 进行刷题。 数组 ( Array ) 链表 ( Linked List ) 栈 ( Stack ) 树 ( Tree ) 二叉搜索树 ( BST ) 字典树...
java-leetcode题解之第141题环形链表.zip
最新发布
06-17
这道题目是数据结构和算法领域的一个经典问题，主要考察对链表的理解以及如何检测一个链表是否存在环。我们将深入探讨这个问题，并提供相关的知识点。 **环形链表** 环形链表是一种特殊类型的链表，其中最后一个...
Leetcode 链表题目
弈秋之鹤的博客
06-23 146
链表是个线性数据结构 由零个或多个数据元素组成的有限序列 第一个元素无前驱，最后一个元素没有后继，其余元素一个前驱一个后继 例题 LeetCod 160、 找出两个链表的交点 本题中要找出两条链表的交点，首先要知道链表的特性，下一个节点的位置只能由上一个节点来确定，所以不能直接确定某个值得特定的位置，因此本题可以采用两轮循环来确定交点的位置，分别同时从A，B 两个链表的头结点开始遍历，遍历完之后，再从赢一个节点开始遍历这样在第二轮是会在交点处相遇。 第一种方法采用双指针的方法。 这个方法有几个注意的地方。
leetcode链表的相关题目
bigorange1的博客
07-08 184
leetcode 链表刷题相关总结
leetcode 链表类题目
Ben
02-24 210
首先谈谈自己对于链表的理解，单链表由结点构成，每一个结点就是一个值加上一个指向其他位置的指针，重要的是这个指针，如果这个指针指向的还是一个节点，则无穷无尽，可以一直续下去。对于链表的操作实际上是对这个指针的操作。 一、链表相加 以下分析两链表数字相加，其中重要的地方是1、位数是否相等 2、是否为零 3、是否进位 代码如下： #include&amp;amp;amp;lt;iostream&amp;amp;amp;gt; using names...
leetcode链表题目整理
ChasingTheFreeWind
10-11 151
剑指Offer 剑指Offer 06.从尾到头打印链表 栈 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: vector<int> reversePrint(ListNo
leetcode链表题整理
fighting_yifeng的博客
12-16 1024
1.2. 两数相加 给你两个非空 的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0开头。 示例 1： 输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[7,0,8] 解释：342 + 465 = 807. 解答：链表入门题 用一个新链表存两链表每个节点之和，在模10即可 class Solution...
leetcode链表相关题目总结
程序员超超的博客
07-28 145
leetCode链表相关题目总结，javascript
链表题目整理（leetcode）
我的博客
01-06 266
1 链表逆序 206 遍历一个链表，建立一个新的链表节点，每次都往新的链表的头部插入， 就实现了逆序 class Solution { public: ListNode* ReverseList(ListNode* pHead) { ListNode *temp; ListNode *ret = 0; while(pHead){ ...
Leetcode 经典题目反转链表三部曲
wwxy1995的博客
09-26 120
1.直接反转一个链表 这个题目在面试中是会考察的，因为代码量很少，要掌握 class Solution{ public ListNode reverseList(ListNode head) { ListNode cur = head, pre = null; while(cur!=null){ ListNode next = ...
leetcode专题训练——链表题目汇总
zyc12321的博客
03-06 189
83. 删除排序链表中的重复元素 两层循环，里面那层负责删除重复元素 82. 删除排序链表中的重复元素 II 创建一条新的链表，把原链表中没有重复的节点串起来 注意：新链表最后一定要指向空节点 206. 反转链表 递归，当递归到最后一个元素时，开始翻转。 ...
Python实现LeetCode合并排序链表经典题解
"在LeetCode中，'合并两个排序数组链表'是一道经典的面试题目，主要考察对递归和链表操作的理解。这里有四种不同的Python实现方式来解决这个问题，它们都属于List Node数据结构的范畴。 首先，第一种方案是通过递归...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CodePanda@GPF

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值