线性表练习之Example009-求两个有序递增链表的差集

最新推荐文章于 2023-09-17 15:34:22 发布
最新推荐文章于 2023-09-17 15:34:22 发布
阅读量2.1k 收藏 36
点赞数 6
分类专栏： 数据结构 文章标签： java c 数据结构 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnds123321/article/details/123784576
版权

Example009

原文链接：Example009

题目

已知递增有序的单链表A、B(A、B中元素个数分别为m、n，且A、B都带有头结点）分别存储了一个集合，请设计算法，以求出两个集合A和B的差集A-B（仅由在A中出现而不在B中出现的元素所构成的集合)。将差集保存在单链表A中，并保持元素的递增有序性。

分析

本题考查的知识点：

  • 单链表
  • 单链表删除节点

分析：

  • 设置两个指针p、q开始时分别指向A和B的开始结点。循环进行以下判断和操作：
  • 如果p所指结点的值小于q所指结点的值，则p后移一位;
  • 如果q所指结点的值小于p所指结点的值，则q后移一位;
  • 如果两者所指结点的值相同，则删除p所指结点。
  • 最后，p与q任一指针为NULL时算法结束。

步骤：

  • 已知两个单链表都是递增有序的，所以才能采用下面的算法，否则要先对链表进行排序。
  • 算法思想如下：循环链表 A 和 B 中的每个节点
  • 如果链表 A 中节点的数据域值小于链表 B 中节点的数据域值，则链表 A 前进一个节点。该节点必然在差集中。
  • 如果链表 A 中节点的数据域值等于链表 B 中节点的数据域值，则删除链表 A 中当前节点，并且让链表 A 和 B 都前进一个节点。在两个链表中都存在的节点一定不会在差集中。
  • 如果链表 A 中节点的数据域值大于链表 B 中节点的数据域值，则链表 B 前进一个节点。
  • 循环结束后，即使链表 A 中还有剩余节点，也会保存在链表 A 中。

注意：

  • 题目要求将两个链表的差集结果保存在链表 A 中，那么必然要删除同时在链表 A 和 B 中出现的节点。
  • 而要删除单链表中的节点，则必须知道被删除节点的前驱节点，所以需要注意保存链表 A 中节点的前驱节点。

图解

请添加图片描述

C实现

核心代码：

/**
 * 求链表 A 和 B 的差集
 * @param aList 链表 A，调用该函数后，差集结果保存在该链表中。注意，因为要修改该单链表，所以形参是指向指针的指针。
 * @param bList 链表 B
 */
void difference(LNode **aList, LNode *bList) {
    // 链表 A 和 B 的第一个节点
    LNode *aNode = (*aList)->next;
    LNode *bNode = bList->next;
    // 记录链表 A 中每个节点的前驱节点，初始为链表的头节点，在删除节点时会用到
    LNode *aPreNode = *aList;

    // 循环两个链表，注意，循环结束的条件是任意一个链表遍历完
    while (aNode != NULL && bNode != NULL) {
        // 如果链表 A 中节点的数据小于链表 B 中节点的数据
        if (aNode->data < bNode->data) {
            // 注意，这里要保存链表 A 中的节点为前驱节点
            aPreNode = aNode;
            // 那么链表 A 前进一步
            aNode = aNode->next;
        }
        // 如果链表 A 中节点的数据等于链表 B 中的节点的数据
        else if (aNode->data == bNode->data) {
            // 删除链表 A 中相等值的节点，即删除 aNode 节点
            aPreNode->next = aNode->next;// 即将 aNode 节点的前驱节点的 next 指针指向 aNode 节点的后继节点，这样就完成了 aNode 节点的删除
            // 那么链表 A 前进一步
            aNode = aNode->next;
            // 那么链表 B 前进一步
            bNode = bNode->next;
        }
        // 如果链表 A 中节点的数据大于链表 B 中的节点的数据
        else {
            // 那么链表 B 前驱节点
            bNode = bNode->next;
        }
    }
}

完整代码：

#include <stdio.h>
#include <malloc.h>

/**
 * 单链表节点
 */
typedef struct LNode {
    /**
     * 单链表节点的数据域
     */
    int data;
    /**
     * 单链表节点的的指针域，指向当前节点的后继节点
     */
    struct LNode *next;
} LNode;

/**
 * 通过尾插法创建单链表
 * @param list 单链表
 * @param nums 创建单链表时插入的数据数组
 * @param n 数组长度
 * @return 创建好的单链表
 */
LNode *createByTail(LNode **list, int nums[], int n) {
    // 1.初始化单链表
    // 创建链表必须要先初始化链表，也可以选择直接调用 init() 函数
    *list = (LNode *) malloc(sizeof(LNode));
    (*list)->next = NULL;

    // 尾插法，必须知道链表的尾节点（即链表的最后一个节点），初始时，单链表的头结点就是尾节点
    // 因为在单链表中插入节点我们必须知道前驱节点，而头插法中的前驱节点一直是头节点，但尾插法中要在单链表的末尾插入新节点，所以前驱节点一直都是链表的最后一个节点，而链表的最后一个节点由于链表插入新节点会一直变化
    LNode *node = (*list);

    // 2.循环数组，将所有数依次插入到链表的尾部
    for (int i = 0; i < n; i++) {
        // 2.1 创建新节点，并指定数据域和指针域
        // 2.1.1 创建新节点，为其分配空间
        LNode *newNode = (LNode *) malloc(sizeof(LNode));
        // 2.1.2 为新节点指定数据域
        newNode->data = nums[i];
        // 2.1.3 为新节点指定指针域，新节点的指针域初始时设置为 null
        newNode->next = NULL;

        // 2.2 将新节点插入到单链表的尾部
        // 2.2.1 将链表原尾节点的 next 指针指向新节点
        node->next = newNode;
        // 2.2.2 将新节点置为新的尾节点
        node = newNode;
    }
    return *list;
}

/**
 * 求链表 A 和 B 的差集
 * @param aList 链表 A，调用该函数后，差集结果保存在该链表中。注意，因为要修改该单链表，所以形参是指向指针的指针。
 * @param bList 链表 B
 */
void difference(LNode **aList, LNode *bList) {
    // 链表 A 和 B 的第一个节点
    LNode *aNode = (*aList)->next;
    LNode *bNode = bList->next;
    // 记录链表 A 中每个节点的前驱节点，初始为链表的头节点，在删除节点时会用到
    LNode *aPreNode = *aList;

    // 循环两个链表，注意，循环结束的条件是任意一个链表遍历完
    while (aNode != NULL && bNode != NULL) {
        // 如果链表 A 中节点的数据小于链表 B 中节点的数据
        if (aNode->data < bNode->data) {
            // 注意，这里要保存链表 A 中的节点为前驱节点
            aPreNode = aNode;
            // 那么链表 A 前进一步
            aNode = aNode->next;
        }
        // 如果链表 A 中节点的数据等于链表 B 中的节点的数据
        else if (aNode->data == bNode->data) {
            // 删除链表 A 中相等值的节点，即删除 aNode 节点
            aPreNode->next = aNode->next;// 即将 aNode 节点的前驱节点的 next 指针指向 aNode 节点的后继节点，这样就完成了 aNode 节点的删除
            // 那么链表 A 前进一步
            aNode = aNode->next;
            // 那么链表 B 前进一步
            bNode = bNode->next;
        }
        // 如果链表 A 中节点的数据大于链表 B 中的节点的数据
        else {
            // 那么链表 B 前驱节点
            bNode = bNode->next;
        }
    }
}

/**
 * 打印链表的所有节点
 * @param list 单链表
 */
void print(LNode *list) {
    printf("[");
    // 链表的第一个节点
    LNode *node = list->next;
    // 循环单链表所有节点，打印值
    while (node != NULL) {
        printf("%d", node->data);
        if (node->next != NULL) {
            printf(", ");
        }
        node = node->next;
    }
    printf("]\n");
}

int main() {
    // 声明单链表 A 和 B
    LNode *aList;
    LNode *bList;

    // 为单链表赋值
    int aNums[] = {1, 2, 3, 5, 7, 9};
    int aN = 5;
    createByTail(&aList, aNums, aN);
    print(aList);
    int bNums[] = {2, 4, 5, 9};
    int bN = 4;
    createByTail(&bList, bNums, bN);
    print(bList);

    // 求两个链表的差集
    difference(&aList, bList);
    print(aList);
}

执行结果：

[1, 2, 3, 5, 7, 9]
[2, 4, 5, 9]
[1, 3, 7]

Java实现

核心代码：

    /**
     * 求链表 A 和 B 的差集，将差集结果保存到 A 链表中
     *
     * @param aList 链表 A
     * @param bList 链表 B
     */
    public void difference(LinkedList aList, LinkedList bList) {
        // 链表 A 和 B 的第一个节点
        LNode aNode = aList.list.next;
        LNode bNode = bList.list.next;
        // 记录链表 A 中每个节点的前驱节点，初始为链表的头节点，在删除节点时会用到
        LNode aPreNode = aList.list;

        // 循环两个链表，注意，循环结束的条件是任意一个链表遍历完
        while (aNode != null && bNode != null) {
            // 如果链表 A 中节点的数据小于链表 B 中节点的数据
            if (aNode.data < bNode.data) {
                // 注意，这里要保存链表 A 中的节点为前驱节点
                aPreNode = aNode;
                // 那么链表 A 前进一步
                aNode = aNode.next;
            }
            // 如果链表 A 中节点的数据等于链表 B 中的节点的数据
            else if (aNode.data == bNode.data) {
                // 删除链表 A 中相等值的节点，即删除 aNode 节点
                aPreNode.next = aNode.next;// 即将 aNode 节点的前驱节点的 next 指针指向 aNode 节点的后继节点，这样就完成了 aNode 节点的删除
                // 那么链表 A 前进一步
                aNode = aNode.next;
                // 那么链表 B 前进一步
                bNode = bNode.next;
            }
            // 如果链表 A 中节点的数据大于链表 B 中的节点的数据
            else {
                // 那么链表 B 前驱节点
                bNode = bNode.next;
            }
        }
    }

完整代码：

/**
 * @author lcl100
 * @create 2022-03-01 21:32
 */
public class LinkedList {
    /**
     * 单链表
     */
    private LNode list;

    /**
     * 通过尾插法创建单链表
     *
     * @param nums 创建单链表时插入的数据
     * @return 创建好的单链表
     */
    public LNode createByTail(int... nums) {
        // 1.初始化单链表
        // 创建链表必须要先初始化链表，也可以选择直接调用 init() 函数
        list = new LNode();
        list.next = null;

        // 尾插法，必须知道链表的尾节点（即链表的最后一个节点），初始时，单链表的头结点就是尾节点
        // 因为在单链表中插入节点我们必须知道前驱节点，而头插法中的前驱节点一直是头节点，但尾插法中要在单链表的末尾插入新节点，所以前驱节点一直都是链表的最后一个节点，而链表的最后一个节点由于链表插入新节点会一直变化
        LNode tailNode = list;

        // 2.循环数组，将所有数依次插入到链表的尾部
        for (int i = 0; i < nums.length; i++) {
            // 2.1 创建新节点，并指定数据域和指针域
            // 2.1.1 创建新节点，为其分配空间
            LNode newNode = new LNode();
            // 2.1.2 为新节点指定数据域
            newNode.data = nums[i];
            // 2.1.3 为新节点指定指针域，新节点的指针域初始时设置为 null
            newNode.next = null;

            // 2.2 将新节点插入到单链表的尾部
            // 2.2.1 将链表原尾节点的 next 指针指向新节点
            tailNode.next = newNode;
            // 2.2.2 将新节点置为新的尾节点
            tailNode = newNode;
        }

        return list;
    }

    /**
     * 求链表 A 和 B 的差集，将差集结果保存到 A 链表中
     *
     * @param aList 链表 A
     * @param bList 链表 B
     */
    public void difference(LinkedList aList, LinkedList bList) {
        // 链表 A 和 B 的第一个节点
        LNode aNode = aList.list.next;
        LNode bNode = bList.list.next;
        // 记录链表 A 中每个节点的前驱节点，初始为链表的头节点，在删除节点时会用到
        LNode aPreNode = aList.list;

        // 循环两个链表，注意，循环结束的条件是任意一个链表遍历完
        while (aNode != null && bNode != null) {
            // 如果链表 A 中节点的数据小于链表 B 中节点的数据
            if (aNode.data < bNode.data) {
                // 注意，这里要保存链表 A 中的节点为前驱节点
                aPreNode = aNode;
                // 那么链表 A 前进一步
                aNode = aNode.next;
            }
            // 如果链表 A 中节点的数据等于链表 B 中的节点的数据
            else if (aNode.data == bNode.data) {
                // 删除链表 A 中相等值的节点，即删除 aNode 节点
                aPreNode.next = aNode.next;// 即将 aNode 节点的前驱节点的 next 指针指向 aNode 节点的后继节点，这样就完成了 aNode 节点的删除
                // 那么链表 A 前进一步
                aNode = aNode.next;
                // 那么链表 B 前进一步
                bNode = bNode.next;
            }
            // 如果链表 A 中节点的数据大于链表 B 中的节点的数据
            else {
                // 那么链表 B 前驱节点
                bNode = bNode.next;
            }
        }
    }

    /**
     * 打印单链表所有节点
     */
    public void print() {
        // 链表的第一个节点
        LNode node = list.next;
        // 循环打印
        String str = "[";
        while (node != null) {
            // 拼接节点的数据域
            str += node.data;
            // 只要不是最后一个节点，那么就在每个节点的数据域后面添加一个分号，用于分隔字符串
            if (node.next != null) {
                str += ", ";
            }
            // 继续链表的下一个节点
            node = node.next;
        }
        str += "]";
        // 打印链表
        System.out.println(str);
    }
}

/**
 * 单链表的节点
 */
class LNode {
    /**
     * 链表的数据域，暂时指定为 int 类型，因为 Java 支持泛型，可以指定为泛型，就能支持更多的类型了
     */
    int data;
    /**
     * 链表的指针域，指向该节点的下一个节点
     */
    LNode next;
}

测试代码：

/**
 * @author lcl100
 * @create 2022-03-01 21:32
 */
public class LinkedListTest {
    public static void main(String[] args) {
        // 创建单链表 A
        LinkedList aList = new LinkedList();
        aList.createByTail(1, 2, 3, 5, 7, 9);
        aList.print();

        // 创建单链表 B
        LinkedList bList = new LinkedList();
        bList.createByTail(2, 4, 5, 9);
        bList.print();

        // 求两个链表的差集
        LinkedList list = new LinkedList();
        list.difference(aList, bList);
        aList.print();
    }
}

执行结果：

[1, 2, 3, 5, 7, 9]
[2, 4, 5, 9]
[1, 3, 7]
二木成林
关注
  • 6
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
利用链表求集合的差集
weixin_49647945的博客
10-04 1193
内容：如果以单链表表示集合，假设集合A用单链表LA表示，集合B用单链表LB表示，设计算法求两集合的差，即A-B。用C语言实现程序解决问题。 算法分析：由集合运算的规则可知，集合的差A-B中包含所有属于集合A而不属于集合B的元素。具体做法是，对于集合A中的每一个元素，在集合B的链表LB中进行查找，若存在与A中元素相同的元素，则在LA中将其删除。 首先需要定义链表结点的结构类型，然后选择使用两个while循环遍历这两个单链表，用pre和q存储相应的结点和待删除的节点，pa和pb分别用来遍历这两个单..
考研数据结构之线性表（1.7）——练习题之求差集A-B（C表示）
二木成林
05-20 2669
题目 已知递增有序的单链表A、B(A、B中元素个数分别为m、n,且A、B都带有头结点)分别存储了一个集合，请设计算法，以求出两个集合A和B的差集A-B(仅由在A中出现而不在B中出现的元素所构成的集合)。将差集保存在单链表A中，并保持元素的递增有序性。 分析 只需从A中删去A与B中共有的元素即可。由于两个链表中的元素是递增有序的，因此可以这么做:设置两个指针p、q开始时分别指向A和B的开始结点。循环进行以下判断和操作:如果p所指结点的值小于q所指结点的值，则p后移一位:如果q所指结点的值小于p所指结..
王道数据结构2022-线性表的链式表示-综合题(p41)-14设A和B是两个单链表(带头结点),其中元素递增有序,设计一个算法从A和B中的公共元素产生单链表C,要求不破坏A,B的结点
好奇独角兽
08-29 626
设A和B是两个单链表(带头结点),其中元素递增有序,设计一个算法从A和B中的公共元素产生单链表C,要求不破坏A,B的结点 #include<stdio.h> #include<stdlib.h> typedef struct LNode { //定义单链表结点类型 int data;//数据域 struct LNode *next;//指针域 } LNode, *LinkList; /*设A和B是两个单链表(带头结点),其中元素递增有序,设计一个算法从A和B中 的公共元素产生
复习笔记7_数据结构线性表（强化习题）
weixin_43700565的博客
07-05 246
一、已知递增有序的单链表A、B(A、B中元素个数分别为m、n，且A、B都带有头结点）分别存储了 一个集合，请设计算法，以求出两个A和B的差集A-B(仅由在A中出现而不在B中出现的元素所构成的集 合）。将差集保存在单链表A中，并保持元素的递增有序性。 (1) 给出算法的基本设计思想。 (2) 根据设计思想，采用C或C++语言描述算法，并在关键之处给出注释。 (3) 说明你所设计的算法的时间复杂度。 ...
14,设A和B是两个单链表(带头结点),其中元素递增有序。设计一个算法从A和B中的 公共元素产生单链表C,要求不破坏A、B的结点。
Anthony_4926
06-29 8012
14,设A和B是两个单链表(带头结点),其中元素递增有序。设计一个算法从A和B中的公共元素产生单链表C,要求不破坏A、B的结点。 思路：二重循环，比较节点，如果相等，新建节点插入L #include<iostream> #include<algorithm> #include<cstdio> #include<cstring> #include<cmath> #include<map> #include<vecto.
数据结构学习--线性表及其应用--链表
06-25
本程序的主要目的在于帮助同学熟练掌握线性表的基本操作在链式存储结构上的实现， 链表的优点是“按需分配”，且增删方便，缺点是不能随机访问。在实际当中，有许多应用 是频繁变动，但并不要求随机访问，在这样的...
数据结构实验报告-线性表-两个有序线性表的归并算法
04-10
从键盘输入数据，建立两个有序线性表(每个线性表的输入数据按由小到大次序输入来建立线性表，不必考虑排序算法)；输出建好的这两个有序线性表；将这两个有序线性表归并为一个有序线性表；输出归并后的有序线性表。 ...
数据结构实验报告1-线性表-两个有序表的归并-实验内容及要求.docx
07-06
从键盘输入数据，建立两个有序线性表(每个线性表的输入数据按由小到大次序输入来建立线性表，不必考虑排序算法)；输出建好的这两个有序线性表；将这两个有序线性表归并为一个有序线性表；输出归并后的有序线性表。 ...
数据结构c版（1）-线性表之双向带头循环链表代码
最新发布
11-19
双向带头循环链表
数据结构---线性表之双链表（C语言）
03-29
数据结构---线性表之双链表，创建、插入、删除，完整的C代码
已知递增有序的单链表 A,B 分别存储了一个集合，请设计算法以求出两个集合 A 和 B 的差集 A-B（即仅由在 A 中出现而不在 B 中出现的元素所构成的集合），并以同样的形式存储，同时返回该集合
thq_kuqi的博客
11-08 402
【代码】已知递增有序的单链表 A,B 分别存储了一个集合，请设计算法以求出两个集合 A 和 B 的差集 A-B（即仅由在 A 中出现而不在 B 中出现的元素所构成的集合），并以同样的形式存储，同时返回该集合。
【PTA】 两个递增链表的差集
m0_74195626的博客
09-17 3682
两个递增链表的差集（山东大学威海校区大二数据结构实验）
两个有序链表求差集，合并为一个有序链表
tk0320的博客
08-16 2028
小白今天刚入门数据结构，正在学习《数据结构高分笔记》，其中第35页仿真题目（2）完成情况如下，如有错误，不吝赐教。 题目要求：已知递增有序的单链表A,B，元素个数分别m，n，分别存储一个集合，请设计算法，求出A与B的差集，将结果保存在A表中，保持元素递增有序。 #in
数据结构——线性表P35.2t
weixin_45614225的博客
12-28 78
已知递增有序的单链表A、B (A、B中元素个数分别为m、n,且A、B都带有头结点)分别存储了一个集合，请设计算法，以求出两个集合A和B的差集A-B (仅由在A中出现而不在B中出现的元素所构成的集合)。将差集保存在单链表A中，并保持元素的递增有序性。 分析： 只需从A中删去A与B中共有的元素即可。由于两个链表中的元素是递增有序的，因此可以这么做:设置两个指针p、q开始时分别指向A和B的开始结点。循环进行以下判断和操作:如果p所指结点的值小于q所指结点的值，则p后移一位;如果q所指结点的值小于p所指结点的值，则
求两个单链表的差集，并以递增形式存储。（C++）
GTC的博客
10-21 1924
求两个单链表的差集，并以递增形式存储。 （1）实现节点类模板，放在node.h文件中； （2）实现线性链表类模板，放在lk_list.h文件中； （3）实现lc返回la与lb表示集合的差集，并使lc中数据元素仍递增有序，放在alg.h文件中。 main.cpp #include <iostream> // 标准流操作 using namespace std; // 标准库包含在命名空间std中 #include "lk_list.h" // 线性链表 #include "
Description 有两个有序数列，数据个数分别为m和n，每个数列中的数均从小到大有序排列。 请把这两个数列合并为一个，输出合并后的数列。 Input 输入数据有两组，每组数据分两行，第1行为两个
qq_40834200的博客
04-30 2111
/*Description 有两个有序数列，数据个数分别为m和n，每个数列中的数均从小到大有序排列。 请把这两个数列合并为一个，输出合并后的数列。 Input 输入数据有两组，每组数据分两行，第1行为两个正整数m和n（m,n<=10）， 第2行有m+n个整数，前m个数属于第1个数列，后n个属于第2个数列，各数列均从小到大 有序。输入保证两个数列中的数任意两个都不相等。 Output 对于每组...
求解出链表A - B的差集
二哈
06-30 2110
1. 问题描述： 已知递增有序的单链表A、B（A、B中元素的个数分别为m，n，而且A、B都带有头节点）分别存储了一个集合，请设计算法，以求出两个集合的差集A - B（仅在链表A中出现而不在链表B出现的元素构成的集合），将差集保存在单链表A中，并保持元素的有序性 2. 思路分析： ① 首先我们需要创建出两个递增有序的单链表A和B，这里使用两个给定的递增有序的数组来创建出两个单链表，创建出来之后...
两个集合用单链表存储，分别求出集合的差集和并集（单链表求差集并集）
ArchyLi
08-01 7239
一、集合求交集题目：已知集合A和B的元素分别用不含头结点的单链表存储，函数difference()用于求解集合A与B的差集，并将结果保存在集合A的单链表中。 例如，若集合A = { 5,10,20,15,25,30 }，集合B = { 5,15,35,25 }，完成计算后A = { 10,20,30 }。 链表结点的结构类型定义如下： struct node { int elem;
将两个递增有序的带头结点的单链表A、B合并成为一个递增有序的带头结点的单链表
热门推荐
cucumber
10-06 1万+
一、题目将两个递增有序的带头结点的单链表A、B合并成为一个递增有序的带头结点的单链表。二、思路将单链表A、B遍历，比较两个链表中元素的值，分为下列情况： A < B,则A的指针向后移一位，然后再与B比较； A=B,则A、B的指针同时向后移一位； A>B,则B的指针向后移一位，然后再与A比较； 注意 若A遍历完，B未遍历完，就将B的剩余部分接到新链表的尾部； 若B遍历完，A未遍历完，就将A的剩余部分接
线性表的应用算法：构造两个按指数递增的有序链表，实现两个一元多项式相加
03-16
2. 构造两个按指数递增的有序链表，分别表示两个多项式。 3. 从两个链表的头部开始遍历，比较当前节点的指数大小，将指数较小的节点加入结果链表，并将指针指向下一个节点。 4. 如果两个节点的指数相同，则将它们...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值