力扣、牛客例题-----链表

最新推荐文章于 2024-06-14 05:47:29 发布
最新推荐文章于 2024-06-14 05:47:29 发布
阅读量2.1k 收藏 44
点赞数 59
分类专栏： JAVA题目 数据结构 文章标签： leetcode 链表 算法 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54176670/article/details/135860221
版权

文章目录

例题1 203.移除链表元素

【题目链接】：
移除链表元素
【题目描述】：
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
在这里插入图片描述
【解题】：
删除所有值为key的节点分为三步：
（1）遍历链表，找到要删除节点cur
（2） 让cur的上一个节点指向cur的下一个节点，删除cur
（3）继续遍历链表，找到所有与key相等的节点，重复（1）（2）步骤，直至遍历完链表

在这里插入图片描述

上述过程没有检查头节点，还有要考虑头节点情况，当要删除的数据是第一个节点时，只需要让head指向第二个节点即可做到删除第一个节点
在这里插入图片描述

public ListNode removeElements(ListNode head, int key) {
        if (head == null) {
            return null;
        }
        ListNode prev = head;
        ListNode cur = head.next;
        while(cur!=null){
            if(cur.val == key){
                prev.next = cur.next;
                cur = cur.next;
            }else {
                prev = cur;
                cur = cur.next;
            }
        }
        if(head.val == key){
            head = head.next;
        }
        return head;
    }

例题2 206.反转链表

【题目链接】：
206.反转链表

【题目描述】：
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
在这里插入图片描述

【解题】：目的：直接反转链表结构

反转前链表：
在这里插入图片描述
反转后链表结构：
在这里插入图片描述
实现过程：

先判断链表是否为空，为空直接返回null，从第二个我节点开始逐个使用头插法插入节点，过程如下：

  1. 首先使用cur保存head的下一个节点，也就是要插入的节点
  2. 将原链表的head节点的next域置为null（反转后成为最后一个节点）
  3. 设置head后的节点为cur，使用curNext记录cur的下一个节点
  4. 使用头插法将cur插入head的前面（插入成功）
  5. head指向cur
  6. cur指向curNext
  7. 重复（3）（4）（5）（6）步骤，直至cur为null，反转完成
    在这里插入图片描述
public ListNode reverseList(ListNode head) {
		//链表为空
        if(head == null) {
            return null;
        }
        //链表只有一个节点
        if(head.next == null) {
        	return head;
        }
        
        ListNode cur = head.next;
        head.next = null;
        while(cur != null) {
            ListNode curNext = cur.next;
            cur.next = head;
            head = cur;
            cur = curNext;
        }
        return head;
    }

例题3 876.链表的中间节点

【题目链接】：
876.链表的中间节点

【题目描述】：
给你单链表的头结点 head ，请你找出并返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。
在这里插入图片描述
在这里插入图片描述

【解题】：
方式一：先求整个链表的长度，再求长度的一半找到中间节点

  1. 先求整个链表的长度
  2. 再求长度的一半找到中间节点
 public ListNode middleNode(ListNode head) {
        if(head == null) {
            return null;
        }
        ListNode cur = head;
        int count = size(head) >> 1;
        while (count != 0){
            cur = cur.next;
            count--;
        }
        return cur;
    }
    //求链表的长度
     public int size(ListNode head) {
        int count = 0;
        ListNode cur = head;
        while (cur != null) {
            cur = cur.next;
            count++;
        }
        return count;
    }

方式二：使用快、慢指针，快指针一次走两步，慢指针一次走一步，当快指针走到终点时，慢指针就刚好停在中间的位置。
在这里插入图片描述

public ListNode middleNode(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }

【注意】： while(fast != null && fast.next != null)该条件语句中的两个语句的位置不能颠倒：
如果颠倒之后语句变成 fast.next != null&&fast != null ，当fast为null时，fast.next就会抛出空指针异常。如果没有颠倒时，当fast为null时，第一个条件成立为false，逻辑运算符&& 遵守短路求值的规则，不会对后一个条件进行判断，不会出现异常情况。

例题4 链表中倒数第k个结点

【题目链接】：
链表中倒数第k个结点
【题目描述】：
输入一个链表，输出该链表中倒数第k个结点。
在这里插入图片描述

【解题】：
考点：快、慢指针
方式一：

  1. 先计算链表的长度len
  2. 然后让节点走len-k步得到节点
 public ListNode FindKthToTail(ListNode head,int k) {
        int len = size(head);
        if(k < 0 || head == null || len - k < 0){
            return null;
        }
        
        ListNode cur = head;
        for(int i = 0;i < len - k;i++){
            cur = cur.next;
        }
        return cur;
        
    }
    //求链表的长度
     public int size(ListNode head) {
        int count = 0;
        ListNode cur = head;
        while (cur != null) {
            cur = cur.next;
            count++;
        }
        return count;
    }

方式二：快、慢指针

  1. 快指针fast先走k-1步
  2. 快指针fast和慢指针slow同时走
  3. 当快指针fast为空时，那么慢指针slow所在的位置就为倒数第k个节点
    原因：快指针fast和慢指针slow之间永远差k-1步，当快指针到达终点，也就是倒数第1的位置时，加上快指针fast和慢指针slow之间k-1步之后，1+（k-1）=k，slow所在的位置就是倒数第k个位置。
    在这里插入图片描述

在这里插入图片描述

public ListNode FindKthToTail(ListNode head,int k) {
		//判断k是否小于0   //当链表为空时，直接返回空
        if(k < 0 || head == null){
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;
        
        int count = 0;
        while(count != (k-1)){
         	fast = fast.next;
            if(fast == null){//判断k是否大于链表的长度
                return null;//要找的节点不存在,超过链表的长度
            }
            count++;
        }
        while(fast.next != null){
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }

例题5 21. 合并两个有序链表

【题目链接】：
21. 合并两个有序链表
【题目描述】：
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
在这里插入图片描述
【解题】：

  1. 新建一个虚拟节点
  2. 比较head1和head2的大小，谁小放在tempH的后面，串联两个链表的所有节点
  3. 如果head1遍历完了，另一个链表head2还没有遍历完只需要temp.next等于head2，串联起来即可
  4. 释放虚拟节点，newH = newH.next;
    在这里插入图片描述
 public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode newH = new ListNode();
        ListNode tmpH = newH;
        while(list1 != null && list2 != null) {
            if(list1.val <= list2.val){
                tmpH.next = list1;
                list1 = list1.next;
                tmpH = tmpH.next;
            }else {
                tmpH.next = list2;
                list2 = list2.next;
                tmpH = tmpH.next;
            }
        }
        if(list1 != null) {
            tmpH.next = list1;
        }
        if(list2 != null) {
            tmpH.next = list2;
        }
        newH = newH.next;
        return newH;
    }

例题6 OR36 链表的回文结构

【题目链接】：
OR36 链表的回文结构
【题目描述】：
对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。

给定一个链表的头指针A，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。
在这里插入图片描述
【解题】：
第一步：找到链表的中间位置
在这里插入图片描述

第二步：从中间位置开始反转
在这里插入图片描述

第三步：从两端开始逐个对比，判断是否是回文

在这里插入图片描述

    public boolean chkPalindrome(ListNode head) {
        // write code here
        //找到中间节点
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }

        //反转后半部分的链表
        ListNode cur = slow.next;
        while(cur != null) {
            ListNode curNext = cur.next;
            cur.next = slow;
            slow = cur;
            cur = curNext;
        }


        //判断是否是回文
        while(slow != head && head.next != slow) {
        //当奇数个节点时，slow和head相等，那么就是回文；
        //当偶数个节点时，slow和head的下一个节点相等，那么就是回文；
            if(slow.val != head.val) {
                return false;
            }
            slow = slow.next;
            head = head.next;
        } 
        return true;
    }

例题7 CM11 链表分割

【题目链接】：
CM11 链表分割
【题目描述】：
现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。

【解题】：
题目分析：
首先要将所有小于x的结点排在其余结点之前，那么可以将链表分为两个部分，一部分为小于c的结点数据，一部分为大于等于x的数据，最后将两部分串联起来；并且题目中提到不能改变原来的数据顺序，所以可以使用尾插法来插入数据，可以保证数据的顺序。

该方法分为以下几个步骤：

  1. 遍历链表的所有节点，小于x的节点放在be的节点的后面，大于等于x的节点放在ae节点的后面
  2. 判断小于x的部分是否为空，如果为空则小于目标值的部分不存在，直接返回后半部分，返回as节点
  3. 将两个部分串联起来
  4. 如果后半部分存在。需要将后半部分的最后一个元素置为null（要不然会陷入死循环）
    在这里插入图片描述
public ListNode partition(ListNode pHead, int target) {
        if (pHead == null) {
            return null;
        }
        // write code here
        //小于目标值的部分
        ListNode bs = null;
        ListNode be = null;
        //大于等于目标值的部分
        ListNode as = null;
        ListNode ae = null;

        ListNode cur = pHead;
        while (cur != null) {
            ListNode curNext = cur.next;
            if (cur.val < target) {
            // bs为null，插入第一个数据节点
                if (bs == null) {
                    bs = cur;
                    be = cur;
                    cur = curNext;
                } else {
                    be.next = cur;
                    be = cur;
                    cur = curNext;
                }
            } else {
                if (as == null) {
                    as = cur;
                    ae = cur;
                    cur = curNext;
                } else {
                    ae.next = cur;
                    ae = cur;
                    cur = curNext;
                }
            }
        }

        //小于目标值的部分不存在
        if (bs == null) {
            return as;
        }
        
        //小于目标值的部分存在
        //将两个部分串联起来
        be.next = as;
        //如果后半部分存在。需要将后半部分的最后一个元素置为null
        if (ae != null) {
            //将最后一个值置为null
            ae.next = null;
        }
        return bs;
    }

例题8 160.相交链表

【题目链接】：
160.相交链表

【题目描述】：
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

图示两个链表在节点 c1 开始相交：
在这里插入图片描述
在这里插入图片描述

【解题】：
在这里插入图片描述
在上图中，节点5便是两个链表的相交点，从节点5之后两个链表的后续节点都是相同的，在上图中只需要同时移动head1和head2，只要两个节点相等时，那么就是相交点。这个方法并不完善，如果两个链表的长度不同时，此方法就不可行，如下图：
在这里插入图片描述
在上图中的两个链表长度并不相同，我们只需要让长的链表先走上两个链表的差值的步数，再按之前的方法，同时移动head1和head2，只要两个节点相等时，那么就是相交点。
解题步骤如下：

  1. 计算两个链表的长度的差值
  2. 并让较长的链表先走差值的步数
  3. 再让两个链表的节点逐个进行对比
  4. 只要相等就是相交点
 public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int len1 = size(headA);
        int len2 = size(headB);
        //计算两个链表的长度的绝对值
        int len = Math.abs(len1 - len2);
        ListNode curA = headA;
        ListNode curB = headB;
        //判断那个链表较长，较长的链表先走差值的步数
        if (len1 > len2) {
            while (len != 0) {
                curA = curA.next;
                len--;
            }
        } else {
            while (len != 0) {
                curB = curB.next;
                len--;
            }
        }
        //两个链表同时走
        while (curA != null && curB != null) {
            //如果存在相等的节点，那么两个链表相交
            if (curA == curB) {
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        //不存在相交点
        return null;

    }

    //计算链表的长度
    public int size(ListNode head) {
        ListNode cur = head;
        int count = 0;
        while (cur != null) {
            cur = cur.next;
            count++;
        }
        return count;
    }

如果用 while (hl != hs) 判断是否走到相交点，还需要判断是否走到链表的结尾，如果走到结尾两个节点并没有相遇但是两个值是相等的
在这里插入图片描述

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        // 使用hl和hs分别指向较长的链表，较短的链表
        ListNode hl = headA;
        ListNode hs = headB;
        // 1.获取两个链表的长度
        int len1 = 0;
        while (hl != null) {
            hl = hl.next;
            len1++;
        }
        int len2 = 0;
        while (hs != null) {
            hs = hs.next;
            len2++;
        }
        int len = len1 - len2;
        hl = headA;
        hs = headB;
        if (len < 0) {
            // 改变hl、hs指针的指向
            hl = headB;
            hs = headA;
            len = len2 - len1;
        }
        // 代码截至到此，hl一定指向较长的链表，hs指向较短的链表

        // 2. 让较长的代码先走差值的步数
        while (len != 0) {
            hl = hl.next;
            len--;
        }

        // 3. 两个链表一起走，如果存在节点相等，那么就是相交点
        while (hl != hs) {
            hl = hl.next;
            hs = hs.next;
        }
        // 判断是否走到链表的结尾，如果走到结尾没有相遇但是两个值是相等的
        if (hl == null) { //不相遇
            return null;
        }
        return hl;//相遇点
    }

例题9 141.环形链表

【题目链接】：
141.环形链表
【题目描述】：
给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。
在这里插入图片描述

【解题】：
【思路】 快、慢指针，即慢指针一次走一步，快指针一次走两步，两个指针从链表起始位置开始运行，如果链表带环则一定会在环中相遇，否则快指针率先走到链表的末尾。比如：陪女朋友到操作跑步减肥。
在这里插入图片描述
再走一步，那么快慢指针就会相遇：
在这里插入图片描述

【扩展问题】

  • 为什么快指针每次走两步，慢指针走一步可以？
    假设链表带环，两个指针最后都会进入环，快指针先进环，慢指针后进环。当慢指针刚进环时，可能就和快指针相遇了，最差情况下两个指针之间的距离刚好就是环的长度。此时，两个指针每移动一次，之间的距离就缩小一步，不会出现每次刚好是套圈的情况，因此：在慢指针走到一圈之前，快指针肯定是可以追上慢指针的，即相遇。
  • 快指针一次走3步，走4步，…n步行吗？
    在这里插入图片描述
  • 无环情况下，快指针会走得快，最快的一定先为空，如果快指针走到结尾null时，那么该链表无环
    在这里插入图片描述
public boolean hasCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while(fast != null && fast.next != null){  
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow) {
                return true;
            }
        }
        return false;
    }
}

 public boolean hasCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) {
                break;
            }
        }
        // 可以在结束循环时，载进行一下判断
        if (fast == null || fast.next == null) {
            return false;
        }
        return false;
    }

例题10 142.环形链表||

【题目链接】：
142.环形链表||
【题目描述】：
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。
在这里插入图片描述

【解题】：
【结论】：
让一个指针从链表起始位置开始遍历链表，同时让一个指针从判环时相遇点的位置开始绕环运行，两个指针都是每次均走一步，最终肯定会在入口点的位置相遇。
【证明】
在这里插入图片描述

 public ListNode detectCycle(ListNode head) {
        // 获取相遇点
        ListNode node = hasCycle(head);
        //相遇点不存在
        if (node == null) {
            return null;
        }
        //相遇点存在
        ListNode fast = node;
        ListNode slow = head;
        //判断入口点
        while (slow != fast) {
            slow = slow.next;
            fast = fast.next;
        }
        //入口点
        return slow;
    }

    public ListNode hasCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) {
                break;
            }
        }
        if (fast == null || fast.next == null) {
            return null;
        }
        return fast;
    }
码农小张~
关注
  • 59
    点赞
  • 踩
  • 44
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode-How-What 力扣Leetcode刷题指南
edwardwjz的博客
03-05 2536
Leetcode-How-What 力扣Leetcode刷题指南 About the way how to use Leetcode wisely for preparing the interview and the solutions to some Leetcode problems’. 怎样为准备面试机智聪明的刷题（高效刷题）以及一些题目的题解。 同 github 链接： https:/...
力扣刷题集-更新至链表
06-21
力扣刷题集-更新至链表 本资源摘要信息主要涉及算法领域，着重于数组、链表、排序算法、二分查找等知识点。 数组 数组是存放在连续内存空间上的相同类型数据的集合。数组可以方便地通过下标索引的方式获取到下标...
能带你起飞的【数据结构】成王第四篇：力扣、牛客链表面试题
m0_64397675的博客
03-15 1076
目录 前言： 兄弟们，继续开干啊，刷题才是永远的王道！！！！！！ 一、链表面试题 1.链表分割 问题描述： 问题分析： 问题解决： 代码实现： 2.删除链表中重复的结点 问题描述： 问题分析： 问题解决： 代码实现： 前言： 兄弟们，继续开干啊，刷题才是永远的王道！！！！！！ 一、链表面试题 1.链表分割 问题描述： 现有一链表的头指针 ListNode*pHead，给一定值x，编写一段代码将所有小于x的结点 排在其余结点之前，且不能改变原来的数据...
力扣例题----二叉树
qq_54176670的博客
02-15 1029
【题目链接】： 100.相同的树 【题目描述】： 给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。 【解题过程】： 两个二叉树相同，当且仅当两个二叉树的结构完全相同，且所有对应节点的值相同。让两个指针一开始先指向两棵二叉树的根节点，然后同步移动两根指针来同步遍历这两棵树，判断对应位置是否相等。 算法实现步骤：【代码】: 复杂度分析： 【时间复杂度】：O(min⁡(m,n))，其中 m 和 n分别是两个二叉树的节点数
数据结构例题(链表) ---猛男专属
weixin_62029250的博客
11-29 498
*链表数据结构例题 1.输入两个链表，找出它们的第一个公共结点: 题目: 给你两个单链表的头节点headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。 图示两个链表在节点 c1 开始相交： 题目数据保证整个链式结构中不存在环。 注意，函数返回结果后，链表必须保持其原始结构。 分析:1.先判断链表是否相交: 设置两个指针遍历两个链表,如果最后的节点地址相同则相交; ...
力扣题解大全-600多页版
08-29
涵盖中高级、各种基本算法和数据机构的运用
【力扣刷题】数组-链表-哈希-双指针
06-21
"数组-链表-哈希-双指针" 在计算机科学中，数组是一种基本的数据结构，用于存储相同类型的数据元素。数组中的每个元素都可以通过下标索引来访问，下标从0开始计数。数组的元素是不能删除的，只能覆盖。不能释放单个...
leetcode力扣是什么-test:测试
06-30
leetcode力扣是什么 写给初中级前端的高级进阶指南 内容来自掘金文章 我的 github 地址: [2] 我的 blog 地址: [3] 写给女朋友的中级前端面试秘籍: [4] JavaScript 深入系列、JavaScript 专题系列、ES6 系列: [5] ...
leetcode力扣是什么-LeetCode:LeetCode练习
06-30
leetcode力扣是什么 从头更新吧，之前单纯的复制题目感觉没有作用，对题目还是应该多思考一些 2020/4/25 46. 全排列 给定一个 没有重复 数字的序列，返回其所有可能的全排列。 示例: 输入: [1,2,3] 输出: [ [1,2,3],...
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 418
【代码】力扣LCP 08.剧情触发时间。
【回溯】Leetcode 77. 组合【中等】
FLGB
06-11 258
你可以按 任何顺序 返回答案。
【代码随想录算法训练Day35】LeetCode 1005. K 次取反后最大化的数组和、LeetCode 134.加油站、LeetCode 135.分发糖果
qq_46121420的博客
06-11 226
贪心第三天
leetcode387：字符串中的第一个唯一字符
Ricky_youngone的博客
06-10 197
这个题目看似简单，实际上很考验你对于字符数组的理解，说白了，这个题目中档，一开始我用的是遍历和标记，最后发现不行。换了unordered_map这个方法，这个方法也是映射，也就是遍历一遍给的字符，把单独的字符在char映射到int中增加1，然后在遍历一遍字符，看看哪个是第一个出现且char映射的int数字只有1，这个就是第一个唯一字符。
Python | Leetcode Python题解之第149题直线上最多的点数
最新发布
Mopes__的博客
06-14 467
Python | Leetcode Python题解之第149题直线上最多的点数
LeetCode //MySQL - 175. Combine Two Tables
Made in Code
06-13 826
【代码】LeetCode //MySQL - 175. Combine Two Tables。
【代码随想录训练营】【Day 50】【动态规划-9】| Leetcode 198, 213, 337
qq_44574200的博客
06-10 432
【代码随想录训练营】【Day 50】【动态规划-9】| Leetcode 198, 213, 337。
力扣24. 两两交换链表中的节点
akdjfhx的博客
06-11 251
力扣24. 两两交换链表中的节点
182.二叉树：二叉搜索树的最小绝对差（力扣）
weixin_63779802的博客
06-13 325
这个算法的时间复杂度是 O(n)，因为每个节点都会被访问一次，其中 n 是树中节点的数量。空间复杂度也是 O(n)，因为需要存储递归调用的栈。
vscode 力扣 链表
09-07
然后，你可以在力扣网站上找到链表相关的题目，并将题目复制到 VSCode 中进行解答。你可以使用适合你选定语言的数据结构来表示链表，并编写相应的解法。在 VSCode 中，你可以使用调试功能逐步执行代码，查看变量的值...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值