链表算法题

最新推荐文章于 2023-01-19 17:54:04 发布
置顶 最新推荐文章于 2023-01-19 17:54:04 发布
阅读量193 收藏 2
点赞数
分类专栏： 算法题 文章标签： 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zdfunk/article/details/119464567
版权

链表相关算法题

206. 反转链表

206. 反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：
在这里插入图片描述

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

迭代法

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null||head.next==null){
            return head;
        }
        ListNode last=reverseList(head.next);
        head.next.next=head;
        head.next=null;
        return last;
    }
}

复杂度分析
时间复杂度：O(n)，其中 n是链表的长度。需要遍历链表一次。
空间复杂度：O(1)。

递归法

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null||head.next==null){
            return head;
        }
       ListNode pre=null;
       ListNode cur=head;
       
       while(cur!=null){
          ListNode next=cur.next;
           cur.next=pre;
           pre=cur;
           cur=next;
       }
       return pre;
    }
}

复杂度分析
时间复杂度：O(n)，其中 n是链表的长度。需要遍历链表一次。
空间复杂度：O(n),空间复杂度主要取决于递归调用的栈空间，最多为 n 层

92. 反转链表 II

92. 反转链表 II
给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

方法一：穿针引线

我们以下图中黄色区域的链表反转为例。
在这里插入图片描述

使用「206. 反转链表」的解法，反转 left 到 right 部分以后，再拼接起来。我们还需要记录 left 的前一个节点，和 right 的后一个节点。如图所示：
在这里插入图片描述

算法步骤：
在这里插入图片描述

第 1 步：先将待反转的区域反转；
第 2 步：把 pre 的 next 指针指向反转以后的链表头节点，把反转以后的链表的尾节点的 next 指针指向 succ。

class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        // 因为头节点有可能发生变化，使用虚拟头节点可以避免复杂的分类讨论
        ListNode dummyNode = new ListNode(-1);
        dummyNode.next = head;

        ListNode pre = dummyNode;
        // 第 1 步：从虚拟头节点走 left - 1 步，来到 left 节点的前一个节点
        // 建议写在 for 循环里，语义清晰
        for (int i = 0; i < left - 1; i++) {
            pre = pre.next;
        }

        // 第 2 步：从 pre 再走 right - left + 1 步，来到 right 节点
        ListNode rightNode = pre;
        for (int i = 0; i < right - left + 1; i++) {
            rightNode = rightNode.next;
        }

        // 第 3 步：切断出一个子链表（截取链表）
        ListNode leftNode = pre.next;
        ListNode curr = rightNode.next;

        // 注意：切断链接
        pre.next = null;
        rightNode.next = null;

        // 第 4 步：同第 206 题，反转链表的子区间
        reverseLinkedList(leftNode);

        // 第 5 步：接回到原来的链表中
        pre.next = rightNode;
        leftNode.next = curr;
        return dummyNode.next;
    }

    private void reverseLinkedList(ListNode head) {
        // 也可以使用递归反转一个链表
        ListNode pre = null;
        ListNode cur = head;

        while (cur != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/reverse-linked-list-ii/solution/fan-zhuan-lian-biao-ii-by-leetcode-solut-teyq/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

方法二：一次遍历（头插法）

方法一的缺点是：如果 left 和 right 的区域很大，恰好是链表的头节点和尾节点时，找到 left 和 right 需要遍历一次，反转它们之间的链表还需要遍历一次，虽然总的时间复杂度为 O(N)，但遍历了链表 2 次，可不可以只遍历一次呢？答案是可以的。
在这里插入图片描述
整体思想是：在需要反转的区间里，每遍历到一个节点，让这个新节点来到反转部分的起始位置。下面的图展示了整个流程。
在这里插入图片描述
使用三个指针变量 pre、curr、next 来记录反转的过程中需要的变量，它们的意义如下：

curr：指向待反转区域的第一个节点 left；
next：永远指向 curr 的下一个节点，循环过程中，curr 变化以后 next 会变化；
pre：永远指向待反转区域的第一个节点 left 的前一个节点，在循环过程中不变。

class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        // 设置 dummyNode 是这一类问题的一般做法
        ListNode dummyNode = new ListNode(-1);
        dummyNode.next = head;
        ListNode pre = dummyNode;
        for (int i = 0; i < left - 1; i++) {
            pre = pre.next;
        }
        ListNode cur = pre.next;
        ListNode next;
        for (int i = 0; i < right - left; i++) {
            next = cur.next;
            cur.next = next.next;
            next.next = pre.next;
            pre.next = next;
        }
        return dummyNode.next;
    }
}

25. K 个一组翻转链表

25. K 个一组翻转链表

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

递归：
在这里插入图片描述

    public ListNode reverseKGroup(ListNode head, int k) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode tail = head;
        for (int i = 0; i < k; i++) {
            //剩余数量小于k的话，则不需要反转。
            if (tail == null) {
                return head;
            }
            tail = tail.next;
        }
        // 反转前 k 个元素
        ListNode newHead = reverse(head, tail);
        //下一轮的开始的地方就是tail
        head.next = reverseKGroup(tail, k);

        return newHead;
    }

    /*
    左闭又开区间
     */
    private ListNode reverse(ListNode head, ListNode tail) {
        ListNode pre = null;
        ListNode next = null;
        while (head != tail) {
            next = head.next;
            head.next = pre;
            pre = head;
            head = next;
        }
        return pre;

    }

.
.

迭代法
步骤分解:

  • 链表分区为已翻转部分+待翻转部分+未翻转部分
  • 每次翻转前，要确定翻转链表的范围，这个必须通过 k 此循环来确定
  • 需记录翻转链表前驱和后继，方便翻转完成后把已翻转部分和未翻转部分连接起来
  • 初始需要两个变量 pre 和 end，pre 代表待翻转链表的前驱，end 代表待翻转链表的末尾
  • 经过k此循环，end 到达末尾，记录待翻转链表的后继 next = end.next
  • 翻转链表，然后将三部分链表连接起来，然后重置 pre 和 end 指针，然后进入下一次循环
  • 特殊情况，当翻转部分长度不足 k 时，在定位 end 完成后，end==null，已经到达末尾，说明题目已完成，直接返回即可
  • 时间复杂度为 O(n*K)最好的情况为 O(n) 最差的情况未 O(n^2)
    空间复杂度为 O(1)除了几个必须的节点指针外，我们并没有占用其他空间
    在这里插入图片描述
public ListNode reverseKGroup(ListNode head, int k) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;

    ListNode pre = dummy;
    ListNode end = dummy;

    while (end.next != null) {
       for (int i = 0; i < k ; i++) {
            end = end.next;
            if(end==null){
                break;
            }
        }
        if (end == null) break;
        ListNode start = pre.next;
        ListNode next = end.next;
        end.next = null;
        pre.next = reverse(start);
        start.next = next;
        pre = start;

        end = pre;
    }

 //如果后面K个也需要翻转，在这里翻转，此时end=null,从pre后面开始翻转
      //  ListNode start=pre.next;
      //  pre.next=reverse(start);

    return dummy.next;
}

private ListNode reverse(ListNode head) {
    ListNode pre = null;
    ListNode curr = head;
    while (curr != null) {
        ListNode next = curr.next;
        curr.next = pre;
        pre = curr;
        curr = next;
    }
    return pre;
}

作者：reals
链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group/solution/tu-jie-kge-yi-zu-fan-zhuan-lian-biao-by-user7208t/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

拓展1：不足k个也要反转

k个一组反转链表，不足k个也要反转

在递归写法中，判断tail是否为空，tail为空，则break，后面翻转head到tail

        for (int i = 0; i < k; i++) {
            //剩余数量小于k的话，则break，后面翻转head到tail.
            if (tail == null) {
               // return head;
               break;
            }
            tail = tail.next;
        }

迭代写法里面：循环结束后，翻转后面剩余节点，见代码注释

拓展2：从尾部开始计数，k个一组翻转

从尾部开始计数，k个一组翻转，不足k个不翻转 比如：
输入：1->2->3->4->5, k = 2
输出：1->3->2->5->4

160. 相交链表

160. 相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        ListNode p1=headA;
        ListNode p2=headB;
       while(p1!=p2){
            if(p1==null){
                p1=headB;
            }else{
                p1=p1.next;
            }

            if(p2==null){
                p2=headA;
            }else{
                p2=p2.next;
            }
        }

        return p1;
    }

}

21. 合并两个有序链表

21. 合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

拓展：考虑去重

递归

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {

        if(l1==null){
            return l2;
        }
        if(l2==null){
            return l1;
        }

        if(l1.val<l2.val){
            l1.next=mergeTwoLists(l1.next,l2);
            return l1;
        }else{
            l2.next=mergeTwoLists(l1,l2.next);
            return l2;
        }
    }
}

要求去重的话，加上相等时候的判断

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {

        if(l1==null){
            return l2;
        }
        if(l2==null){
            return l1;
        }

        if(l1.val<l2.val){
            l1.next=mergeTwoLists(l1.next,l2);
            return l1;
        }else if(l1.val==l2.val){
            return mergeTwoLists(l1.next,l2);
        }else{
            l2.next=mergeTwoLists(l1,l2.next);
            return l2;

        }

    }
}

迭代

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode prehead = new ListNode(-1);

        ListNode prev = prehead;
        while (l1 != null && l2 != null) {
            if (l1.val <= l2.val) {
                prev.next = l1;
                l1 = l1.next;
            } else {
                prev.next = l2;
                l2 = l2.next;
            }
            prev = prev.next;
        }

        // 合并后 l1 和 l2 最多只有一个还未被合并完，我们直接将链表末尾指向未合并完的链表即可
        prev.next = l1 == null ? l2 : l1;

        return prehead.next;
    }
}

去重的话，加一个判断

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {

        ListNode dumpy =new ListNode(-1);
        ListNode pre=dumpy;
        while(l1!=null&&l2!=null){
            if(l1.val<l2.val){
                pre.next=l1;
                l1=l1.next;
            }else if(l1.val==l2.val){
                l1=l1.next;
                continue;
            }
            else{
                pre.next=l2;
                l2=l2.next;
            }

            pre=pre.next;
        }

        pre.next=l1==null?l2:l1;
        return dumpy.next;

    }
}

23. 合并K个升序链表

23. 合并K个升序链表

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        return merge(lists, 0, lists.length - 1);
    }

    public ListNode merge(ListNode[] lists, int l, int r) {
        if (l == r) {
            return lists[l];
        }
        if (l > r) {
            return null;
        }
        int mid = (l + r) >> 1;
        return mergeTwoLists(merge(lists, l, mid), merge(lists, mid + 1, r));
    }

    public ListNode mergeTwoLists(ListNode a, ListNode b) {
        if (a == null || b == null) {
            return a != null ? a : b;
        }
        ListNode head = new ListNode(0);
        ListNode tail = head, aPtr = a, bPtr = b;
        while (aPtr != null && bPtr != null) {
            if (aPtr.val < bPtr.val) {
                tail.next = aPtr;
                aPtr = aPtr.next;
            } else {
                tail.next = bPtr;
                bPtr = bPtr.next;
            }
            tail = tail.next;
        }
        tail.next = (aPtr != null ? aPtr : bPtr);
        return head.next;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/he-bing-kge-pai-xu-lian-biao-by-leetcode-solutio-2/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

143. 重排链表

143. 重排链表

给定一个单链表 L 的头节点 head ，单链表 L 表示为：

 L0 → L1 → … → Ln-1 → Ln

请将其重新排列后变为：

L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → …

不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

方法一：线性表
因为链表不支持下标访问，所以我们无法随机访问链表中任意位置的元素。

因此比较容易想到的一个方法是，我们利用线性表存储该链表，然后利用线性表可以下标访问的特点，直接按顺序访问指定元素，重建该链表即可。

class Solution {
    public void reorderList(ListNode head) {
        if (head == null) {
            return;
        }
        List<ListNode> list = new ArrayList<ListNode>();
        ListNode node = head;
        while (node != null) {
            list.add(node);
            node = node.next;
        }
        int i = 0, j = list.size() - 1;
        while (i < j) {
            list.get(i).next = list.get(j);
            i++;
            if (i == j) {
                break;
            }
            list.get(j).next = list.get(i);
            j--;
        }
        list.get(i).next = null;
    }
}

方法二：寻找链表中点 + 链表逆序 + 合并链表

class Solution {
    public void reorderList(ListNode head) {
        if (head == null) {
            return;
        }
        ListNode mid = middleNode(head);
        ListNode l1 = head;
        ListNode l2 = mid.next;
        mid.next = null;
        l2 = reverseList(l2);
        mergeList(l1, l2);
    }

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

    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode nextTemp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = nextTemp;
        }
        return prev;
    }

    public void mergeList(ListNode l1, ListNode l2) {
        ListNode l1_tmp;
        ListNode l2_tmp;
        while (l1 != null && l2 != null) {
            l1_tmp = l1.next;
            l2_tmp = l2.next;

            l1.next = l2;
            l1 = l1_tmp;

            l2.next = l1;
            l2 = l2_tmp;
        }
    }
}

141. 环形链表

public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head==null||head.next==null){
            return false;
        }
        ListNode slow=head;
        ListNode fast=head.next;

        while(slow!=fast){
            slow=slow.next;
            if(fast!=null && fast.next!=null){
                fast=fast.next.next;
            }else{
                return false;
            }
        }
        return true;
        
    }
}

142. 环形链表 II

142. 环形链表 II

public class Solution {
    public ListNode detectCycle(ListNode head) {
          if(head==null||head.next==null){
            return null;
        }
        ListNode slow=head;
        ListNode fast=head;

        while(true){
            if(fast==null||fast.next==null){
                return null;
            }
            slow=slow.next;
            fast=fast.next.next;
            if(slow==fast){
                break;
            }
        }
        ListNode res=head;
        while(res!=slow){
            slow=slow.next;
            res=res.next;
        }
        return res;
    }
}

链表反转从尾部开始

给定一个单链表的头节点 head,实现一个调整单链表的函数，使得每K个节点之间为一组进行逆序，并且从链表的尾部开始组起，头部剩余节点数量不够一组的不需要逆序。（不能使用队列或者栈作为辅助）

例如：链表:1->2->3->4->5->6->7->8->null, K = 3。那么 6->7->8，3->4->5，1->2各位一组。调整后：1->2->5->4->3->8->7->6->null。其中 1，2不调整，因为不够一组。

只需要先把单链表进行一次逆序，逆序之后就能转化为从头部开始组起了，然后按照上面的解法，处理完之后，把结果再次逆序即搞定。两次逆序相当于没逆序。

zdfunk
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表经典算法题
Frank的博客
10-03 1692
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
【精挑细讲】这 10 道链表相关算法题，将助你告别链表问题（上）
weixin_34389926的博客
06-01 139
精选挑选了9道链表相关是算法题，每道都给出了对应的解答以及技巧，看完这些链表问题，相信你再也不怕链表问题了，建议点赞、收藏。 为了方便大家查找，我这里先给出个目录 1、如何优雅着反转单链表 2、环形单链表约瑟夫问题最优解 3、三种方法带你优雅判断回文链表 4、删除单链表的中间节点 5、将单向链表按某值划分成左边小，中间相等，右边大的形式 6、复制含有随机指针节点的链表 7、将单链表的每K个节点之间...
【数据结构】链表经典算法题集锦
林慢慢的博客
09-12 9586
前言：本章将分享十一道来自LeetCode/牛客网中的经典链表算法题来介绍数据结构中链表在算法题中的应用。 文章目录1.删除链表元素思路分析：题解：2.反转链表思路分析：题解：3.链表中间结点思路分析（快慢指针法）：题解：4.链表中倒数第K个结点思路分析（快慢指针法）：题解：5.合并两个有序链表思路分析：题解：6.链表分割思路分析：题解：7.链表的回文结构(第2题和第3题的综合)思路分析：题解：8.相交链表思路分析：题解：9.环形链表I思路分析：题解：10.环形链表II思路分析：题解：11.复制带随机指针
链表类算法题
qq_33690342的博客
02-19 601
1、反转链表leetcode 206： // ListNode Definition for singly-linked list. type ListNode struct { Val int Next *ListNode } func reverseList(head *ListNode) *ListNode { if head == nil || head.Next == nil { return head } var prev *Li
python算法题 链表反转详解
09-19
主要介绍了python算法题 链表反转,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java算法练习-环形链表插值练习题
10-01
java学习
Java算法练习-链表的分化练习题
最新发布
10-07
java
链表 http://hi.baidu.com/silverxinger/item/3adfff97fcff3245f14215a6
coding for life
12-05 1095
数据结构-链表-奇思妙想 基本函数 1，构造节点：  //定义节点类型 struct Node { int value; Node*next; };   2，分配节点 //之所以要分配节点原因是需要在分配函数中进行初始化，并且也利于判断是否分配成功。 Node* applyNode();   3，在头部增加节点 //增加节点在头部（无头结点）,返回值的原因是由于传入并
链表的算法题
flyingcloud6的博客
01-19 1426
不用太在乎空间复杂度，一切为了时间复杂度。时间复杂度依然放在第一位，但一定要找到空间最省的办法。
链表经典算法题实现
思考、总结、专注
09-18 2683
本文包含链表的以下内容： 　　1、单链表的创建和遍历 　　2、求单链表中节点的个数 　　3、查找单链表中的倒数第k个结点（剑指offer，题15） 　　4、查找单链表中的中间结点 　　5、合并两个有序的单链表，合并之后的链表依然有序【出现频率高】（剑指offer，题17） 　　6、单链表的反转【出现频率最高】（剑指offer，题16） 　　7、从尾到头打印单链表（剑指offer，题5...
两个链表相交的一系列问题
OY_palada
07-26 366
程序员代码面试指南（左程云）读书笔记  第二章 两个链表相交的一系列问题   在本题中单链表可能有环，也可能没有环。给定连个单链表的头节点，head1和head2,这连个链表可能相交，也可能不相交。 请实现一个函数，如果两个链表相交，请返回相交的第一个节点，如果不相交，返回null; 要求：      如果链表1的长度为N,链表2的长的为W,时间复杂度问O（N+W）,额外空间复
链表相关算法题
无关风月
05-03 179
从尾到头打印链表 https://lovezxm.blog.csdn.net/article/details/80781538 链表合并 https://leetcode-cn.com/problems/merge-two-sorted-lists/ 题目描述：将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 题解： 方法一：递归 递归地定义两个链表里的 merge 操作（忽略边界情况，比如空链表等）： 也就是说，两个链表头部值较小的一个节点与剩下元素的 m
常用算法整理：链表相关
言川的博客
04-24 3730
链表的考点链表很多时候都是考察基本功，因为链表题大部分都不是很复杂，主要是对指针的操作，当然也有难的。 简单的题目包括 删除/插入节点、翻转、去重、排序等，难度高一些的题目依然是这些，不过会有一些条件，比如多个链表或者局部操作。对链表题的两个技巧： - 如果不确定最终结果的head，比如对两个链表进行排序，那么新建一个 dummy node。 - 可以通过快慢指针的方式取中间节点入门题：第一题
【算法】链表算法题思路
onlyongwang的博客
08-07 556
做了很多链表相关的算法题，感觉解题思路不外乎下面三种： 1. 一快一慢双指针 比如，倒数第k个节点问题，判断有环链表的入环节点 2. 使用栈结构 比如， 3. pre，cur，next三指针同时出击。 比如，链表翻转问题...
几道链表相关的算法题
qq_31473465的博客
06-27 179
前置条件： public class ListNode { int val; ListNode next; ListNode(int x) { val = x; } } 一、给定一个链表，删除链表的倒数第n个节点，并且返回链表的头结点。 /** * 给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。 * &lt...
链表相关的算法题大汇总 （1）— 数据结构之链表奇思妙想
十年磨一剑，沉淀……
09-28 655
声明：转自http://hi.baidu.com/lanxuezaipiao/item/afc616caf8393a155050585b 基本函数（具体代码实现见后面） 1，构造节点 //定义节点类型 struct Node { int value; Node*next; }; 2，分配节点 //之所以要分配节点原因是需要在分配函数中进行初始化，并且也...
【常用算法思路分析系列】链表相关高频题集
开心阳
05-24 7346
本文是【常用算法思路分析系列】的第四篇，总结链表相关的高频题目和解题思路。本文分析如下几个问题：1、环形链表的差值问题；2、只能访问单个结点的删除问题；3、链表的分化；4、打印两个链表的公共部分；5、把链表的每k个结点逆序；6、删除链表中指定结点；7、判断链表是否为回文结构；8、复杂链表的复制；9、判断链表是否有环；10、判断两个无环链表是否相交；11、判断两个有环链表是否相交；12、判断两个链表

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值