单向链表，双向链表，内核链表，栈，队列简单操作

于 2024-08-29 21:55:44 发布
阅读量553 收藏 2
点赞数 18
文章标签： 链表 数据结构 linux 学习 c语言 软件构建
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zm1332006603/article/details/141687621
版权

1.单向链表

        1.1创建空节点

        link_t 为宏定义的链表节点结构体，typedef struct linknode{struct linknode pnext; DateType   data; }link_t;  其中DateType为宏定义的数据类型#define  int DateType；

link_t *CreateLinkNode(void)
{
    link_t *phead = NULL;

    phead = malloc(sizeof(link_t));
    if (phead == NULL)
    {
        return NULL;
    }

    phead->pnext = NULL;

    return phead;
}

        1.2头插法插入节点

int HeadInsertLinkList(link_t *phead, DateType tmpdate)
{
    link_t *newnode = NULL;

    //申请空间
    newnode = malloc(sizeof(link_t));
    if (NULL == newnode)
    {
        return -1;
    }

    //对两个成员赋值
    newnode->data = tmpdate;
    newnode->pnext = phead->pnext;

    //头结点指向新节点
    phead->pnext = newnode;

    return 0;
}

        1.3尾插法插入节点

//尾插法
int TailInsertLinkList(link_t *phead, DateType tmpdate)
{   
    link_t *ptemp = NULL;
    link_t *newlink = NULL;

    ptemp = phead;
    while (ptemp->pnext != NULL)
    {
        ptemp = ptemp->pnext;
    }

    newlink = malloc(sizeof(link_t));
    if (newlink == NULL)
    {
        return -1;
    }

    newlink->data = tmpdate;
    newlink->pnext = NULL;

    ptemp->pnext = newlink;

    return 0;
}

        1.4遍历链表

//打印链表内容
int ShowLinkList(link_t *phead)
{
    link_t *ptemp = NULL;

    ptemp = phead->pnext;
    while (ptemp != NULL)
    {
        printf("%d ", ptemp->data);
        ptemp = ptemp->pnext;
    }
    printf("\n");

    return 0;
}

        1.5修改链表数据

//修改链表数据
int UpdateLinkList(link_t *phead, DateType olddate, DateType newdate)
{
    //遍历链表，查找数据
    link_t *ptemp = NULL;

    ptemp = phead->pnext;
    while (ptemp != NULL)
    {
        if (ptemp->data == olddate)
        {
            ptemp->data = newdate;
            break;
        }
        ptemp = ptemp->pnext;
    }

    return 0;
}

        1.6查找链表数据

//查找链表数据
link_t *FindLinkList(link_t *phead, DateType tmpdate)
{
    link_t *ptemp = NULL;

    ptemp = phead->pnext;
    while (ptemp != NULL)
    {
        if (ptemp->data == tmpdate)
        {
            break;
        }
        ptemp = ptemp->pnext;
    }

    return ptemp;
}

        1.7删除链表节点

        定义两个结构体指针，分别指向头节点和下一节点，遍历链表，同时两个指针同步向下走，直到需要删除的节点

//删除链表
int DeleteLinkList(link_t *phead, DateType tempdate)
{
    link_t *pfirst = NULL;
    link_t *psecend = NULL;
    int cnt = 0;

    pfirst = phead;
    psecend = phead->pnext;

    while (psecend != NULL)
    {
        if (psecend->data == tempdate)
        {
            pfirst->pnext = psecend->pnext;
            free(psecend);
            psecend = pfirst->pnext;
            cnt++;
        }
        else
        {
            pfirst = pfirst->pnext;
            psecend = psecend->pnext;
        }
        
    }

    return cnt;
}

        1.8销毁链表

//销毁链表
int DestoryLinkList(link_t **phead)
{
    link_t *pfirst = NULL;
    link_t *psecend = NULL;

    psecend = pfirst = (*phead);

    while (psecend != NULL)
    {
        psecend = psecend->pnext;
        free(pfirst);
        pfirst = psecend;
        
    }

    (*phead) = NULL;

    return 0;
}

        1.9查找链表中间节点

        定义两个指针，一快，一慢，快指针走过的距离始终是慢指针走过距离的两倍，走到最后慢指针指向的节点为中间节点

link_t *FindMedleLinkList(link_t *phead)
{
    link_t *pfast = NULL;
    link_t *pslow = NULL;

    pfast = pslow = phead->pnext;

    while (pfast != NULL)
    {
        pslow = pslow->pnext;
        pfast = pfast->pnext;
        if (pfast != NULL)
        {
            pfast = pfast->pnext;
        }
    }

    return pslow;
}

        1.10找到单向链表倒数第K个节点

        同样定义两个指针， 一快，一慢，快指针先走k个距离，然后两只指针在同时向下走，最后慢指针指向的节点为第K个节点

//找到倒数第k个节点
link_t *FindNumKLinkList(link_t *phead, DateType tempdate)
{
    link_t *pfast = NULL;
    link_t *pslow = NULL;
    int i = 0;

    pfast = phead;
    pslow = phead;

    for (i = 0; i < tempdate; i++)
    {
        pfast = pfast->pnext;
        if (pfast == NULL)
        {
            return NULL;
            break;
        }
    }

    while (pfast != NULL)
    {
        pfast = pfast->pnext;
        pslow = pslow->pnext;
    }

    return pslow;
}

       1.11倒置 

//链表倒置
int IvertLinkList(link_t *phead)
{
    link_t *ptemplink = NULL;
    link_t *pinvertlink = NULL;

    ptemplink = phead->pnext;
    phead->pnext = NULL;
    pinvertlink = ptemplink;

    while (ptemplink != NULL)
    {
        ptemplink = ptemplink->pnext;
        pinvertlink->pnext = phead->pnext;
        phead->pnext = pinvertlink;
        pinvertlink = ptemplink;
    }

    return 0;
}

        1.12冒泡排序

//链表冒泡排序
int BubbleSortLinkList(link_t *phead)
{
    link_t *ptemplink1 = NULL;
    link_t *ptemplink2 = NULL;
    link_t *pend = NULL;
    DateType tempdate;

    if (phead->pnext == NULL || phead->pnext->pnext == NULL)
    {
        return 0;
    }
    
    while (pend != phead->pnext->pnext)
    {
        ptemplink1 = phead->pnext;
        ptemplink2 = phead->pnext->pnext;
        while (ptemplink2 != pend)
        {
            if (ptemplink1->data > ptemplink2->data)
            {   
                tempdate = ptemplink1->data;
                ptemplink1->data = ptemplink2->data;
                ptemplink2->data = tempdate;
            }

            ptemplink1 = ptemplink1->pnext;
            ptemplink2 = ptemplink2->pnext;
        }
        pend = ptemplink1;
    }

    return 0;
}

        1.13选择排序

//选择排序
int SelectLinkList(link_t *phead)
{
    link_t *pmin = NULL;
    link_t *ptemp = NULL;
    link_t *pswap = NULL;
    DateType tempdate = 0;

    if (phead->pnext == NULL || phead->pnext->pnext == NULL)
    {
        return 0;
    }

    pswap = phead->pnext;

    while (pswap->pnext != NULL)
    {
        pmin = pswap;
        ptemp = pswap->pnext;
        while (ptemp != NULL)
        {
            if (ptemp->data > pmin->data)
            {
                pmin = ptemp;
            }
            ptemp = ptemp->pnext;
        }
        if (pmin != pswap)
        {
            tempdate = pmin->data;
            pmin->data = pswap->data;
            pswap->data = tempdate;
        }
        pswap = pswap->pnext;
    }

    return 0;
}

        1.14判断是否有环，以及环长为多少

        定义快慢指针， 循环向下走，当快慢指针相同时即为有环，并定义一个指向慢指针，即快慢指针的相遇点。若快指针走到NULL即该链表没有环。

        定义一个指针指向相遇点，从该点开始循环并计数cnt，当该指针回到该点时cnt的值为环长

        定义两个指针，一个指向相遇点，一个指向第一个有效节点即phead->pnext，两指针同时向下走，当两指针相遇时的节点即换入口位置

//判断链表是否有环
//实现方式：
//     快指针每次走2步，慢指针每次走1步
//     两者能够相遇即为有环
LinkNode *IsHasCircle(LinkNode *pHead, int *pcnt)
{
    LinkNode *pFast = NULL;
    LinkNode *pSlow = NULL;
    LinkNode *pTmpNode = NULL;
    LinkNode *pNode1 = NULL;
    LinkNode *pNode2 = NULL;
    int ret = 0;
    int cnt = 1;

    pSlow = pFast = pHead->pNext;
    while (1)
    {
        pFast = pFast->pNext;
        if (NULL == pFast)
        {
            ret = 0;
            break;
        }
        pFast = pFast->pNext;
        if (NULL == pFast)
        {
            ret = 0;
            break;
        }

        pSlow = pSlow->pNext;
        if (pSlow == pFast)
        {
            ret = 1;
            break;
        }
    }

    if (1 == ret)
    {
        //获得环长
        pTmpNode = pSlow->pNext;
        while (pTmpNode != pSlow)
        {
            cnt++;
            pTmpNode = pTmpNode->pNext;
        }
        *pcnt = cnt;

        //获得环入口位置
        pNode1 = pSlow;
        pNode2 = pHead->pNext;
        while (1)
        {
            pNode1 = pNode1->pNext;
            pNode2 = pNode2->pNext;
            if (pNode1 == pNode2)
            {
                return pNode1;
            }
        }
    }

    return NULL;
}

2.双向链表

        2.1创建头节点

//创建头节点
LinkNode *CreateDoubleLinkNode(void)
{
    LinkNode *phead = NULL;

    phead = malloc(sizeof(LinkNode));
    if (phead == NULL)
    {
        return NULL;
    }

    phead->pPre = NULL;
    phead->pNext = NULL;

    return phead;
}

        2.2头插法插入

//头插法插入
int HeadInsertLinkNode(LinkNode *phead, DateType tempdate)
{
    LinkNode *NewNode = NULL;

    NewNode = malloc(sizeof(LinkNode));
    if (NewNode == NULL)
    {
        return -1;
    }

    NewNode->date = tempdate;
    NewNode->pNext = phead->pNext;
    phead->pNext = NewNode;
    NewNode->pPre = phead;
    if (NewNode->pNext != NULL)
    {
        NewNode->pNext->pPre = NewNode;
    }

    return 0;
}

        2.3尾插法插入

//尾插法插入
int TailInsertLinkNode(LinkNode *phead, DateType tempdate)
{
    LinkNode *NewNode = NULL;
    LinkNode *pTempNode = NULL;

    NewNode = malloc(sizeof(LinkNode));
    if (NewNode == NULL)
    {
        return -1;
    }

    pTempNode = phead->pNext;
    if (pTempNode == NULL)
    {
        HeadInsertLinkNode(phead, tempdate);
    }
    while (pTempNode->pNext != NULL)
    {
        pTempNode = pTempNode->pNext;
    }

    NewNode->date = tempdate;
    NewNode->pNext = NULL;
    NewNode->pPre = pTempNode;
    pTempNode->pNext = NewNode;

    return 0;
}

        2.4遍历链表

//头插法插入
int HeadInsertLinkNode(LinkNode *phead, DateType tempdate)
{
    LinkNode *NewNode = NULL;

    NewNode = malloc(sizeof(LinkNode));
    if (NewNode == NULL)
    {
        return -1;
    }

    NewNode->date = tempdate;
    NewNode->pNext = phead->pNext;
    phead->pNext = NewNode;
    NewNode->pPre = phead;
    if (NewNode->pNext != NULL)
    {
        NewNode->pNext->pPre = NewNode;
    }

    return 0;
}

        2.5删除链表节点

//删除节点
int DeleteLinkNode(LinkNode *phead, DateType tempdate)
{
    LinkNode *pTempNode = NULL;
    LinkNode *pRetNode = NULL;

    pTempNode = phead->pNext;
    pRetNode = phead->pNext;

    while (pTempNode != NULL)
    {
        pRetNode = pRetNode->pNext;
        if (pTempNode->date == tempdate && pTempNode->pNext != NULL)
        {
            pTempNode->pPre->pNext = pTempNode->pNext;
            pTempNode->pNext->pPre = pTempNode->pPre; 
            free(pTempNode);
        }
        else if (pTempNode->date == tempdate && pTempNode->pNext == NULL)
        {
            pTempNode->pPre->pNext = NULL;
            free(pTempNode);
        }
        pTempNode = pRetNode;
    }

    return 0;
}

        2.6销毁链表

//销毁链表
int DestoryLinkNode(LinkNode **phead)
{
    LinkNode *pTempNode = NULL;

    if ((*phead)->pNext == NULL)
    {
        free(*phead);
        *phead = NULL;
        return 0;
    }
    if ((*phead)->pNext->pNext == NULL)
    {
        pTempNode = (*phead)->pNext;
        free(pTempNode);
        free(*phead);
        *phead = NULL;
        return 0;
    }
    else 
    {
        pTempNode = (*phead)->pNext->pNext;
        while (pTempNode != NULL)
        {
            free(pTempNode->pPre);
            if (pTempNode->pNext == NULL)
            {
                break;
            }
            pTempNode = pTempNode->pNext;
        }
        free(pTempNode);
        free(*phead);
        *phead = NULL;
    }

3.内核链表

        3.1概念

        内核链表基于双向链表

        一种内核链表可以操作多种数据类型的对象

        数据包含节点，数据节点与链表节点相同类型不同，需要进行强制转换

        3.2示例

        其中list.h为内核链表宏定义文件

#include "list.h"
#include <stdio.h>
#include <stdlib.h>

//定义数据类型结构
typedef struct data
{
    struct list_head node;
    char name[64];
    char sex[32];
    int age;
    double score;
}stu_t;


int main(void)
{
    struct list_head head;
    struct list_head *pTmpNode = NULL;
    stu_t *pdata = NULL;

    INIT_LIST_HEAD(&head);    //初始化头节点

    stu_t tmp1 = {{NULL, NULL}, "zhangsan", "male", 16, 75.6};    //插入数据
    list_add(&tmp1.node, &head);                                  //头插法插入数据节点

    stu_t tmp2 = {{NULL, NULL}, "lisi", "fmale", 21, 33.3};
    list_add(&tmp2.node, &head);

    stu_t tmp3 = {{NULL, NULL}, "wanger", "male", 88, 49.8};
    list_add(&tmp3.node, &head);

    stu_t tmp4 = {{NULL, NULL}, "zhaoliu", "male", 55, 88.8};
    list_add_tail(&tmp4.node, &head);

    stu_t tmp5 = {{NULL, NULL}, "laoba", "fmale", 44, 92.1};
    list_add_tail(&tmp5.node, &head);

    list_for_each(pTmpNode, &head)
    {
        pdata = (stu_t *)pTmpNode;        //强制类型转换，将链表节点转换为数据节点
        printf("name = %-10s sex = %-5s age = %-4d score = %-.2lf\n", pdata->name, pdata->sex, pdata->age, pdata->score);
    }

    return 0;
}

4.栈        

        4.1概念

        栈和队列只允许在固定位置插入和删除

        表可以在任何位置插入删除

    先进后出，后进先出 
    栈顶：允许入栈出栈的一端称为栈顶
    栈底：不允许入栈和出栈的一端称为栈底
    入栈（压栈）：将数据元素放入栈顶
    出栈（弹栈）：将数据元素从栈顶位置取出

        分类：空增栈， 空减栈，满增栈，满减栈，顺序栈，链式栈

        4.2创建空增栈

//创建空增栈
stack_t *CreateSeqstack(int MAXLEN)
{
    stack_t *pTmpStack = NULL;

    pTmpStack = malloc(sizeof(stack_t));
    if (pTmpStack == NULL)
    {
        return NULL;
    }

    pTmpStack->tLen = MAXLEN;
    pTmpStack->Top = 0;

    pTmpStack->pData = malloc(sizeof(DataType) * MAXLEN);
    if (pTmpStack->pData == NULL)
    {
        return NULL;
    }

    return pTmpStack;
}

        4.3判断栈是否为空，是否存满

//判断栈有没有满
int IsFullSeqstack(stack_t *pStack)
{
    return pStack->Top == pStack->tLen ? 1 : 0;
}

//判断栈是不是空
int IsEmptySeqstack(stack_t *pStack)
{
    return 0 == pStack->Top ? 1 : 0;
}

        4.4压栈，出栈

//进栈
int EnterSeqstack(stack_t *pStack, DataType tmpdata)
{
    if (IsFullSeqstack)
    {
        return -1;
    }

    pStack->pData[pStack->Top] = tmpdata;
    pStack->Top++;

    return 0;
}

//出栈
DataType PopSeqstack(stack_t *pStack)
{
    if (IsEmptySeqstack)
    {
        return -1;
    }

    pStack->Top--;

    return pStack->pData[pStack->Top];
}

        4.5销毁栈

//销毁栈
int DestorySeqstack(stack_t **pStack)
{
    (*pStack)->Top = 0;

    free((*pStack)->pData);
    free(*pStack);
    *pStack = NULL;

    return 0;
}

        4.6链式栈

#include "list.h"
#include <stdio.h>
#include <stdlib.h>

typedef struct data
{
    struct list_head naode;
    int pData;
}data_t;

int main(void)
{
    struct list_head head;
    int i = 0;
    struct list_head *pTmpNode = NULL;

    INIT_LIST_HEAD(&head);

    data_t D[5] = {
        {{NULL, NULL}, 1},
        {{NULL, NULL}, 2},
        {{NULL, NULL}, 3},
        {{NULL, NULL}, 4},
        {{NULL, NULL}, 5}
    };

    for (i = 0; i < 5; i++)
    {
        list_add(&D[i].naode, &head);
    }
    
    while (!list_empty(&head))
    {
        pTmpNode = head.next;
        printf("%d ", list_entry(pTmpNode, data_t, naode)->pData);
        list_del(head.next);
    }

    printf("\n");

    return 0;
}

5.队列

        5.1队列

        先进先出

        栈和队列只允许在固定位置插入和删除

        表可以在任何位置插入删除

安亿103
关注
  • 18
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【手写数据库内核组件】0102 链表的类型，单向链表，双向链表，循环链表，二叉树，多路树等类型以及它们的特点，物尽其用
一个追逐梦想的码农
08-28 131
程序就是算法 + 数据结构， 今天我们就来看看最基础的数据结构——链表。 在实际软件应用中，经常需要存储数据，往往存储的数据量在运行时会随着情况的变化而变化； 而链表就是一个很好的容器，可以很好的应对变化，不仅对于链表中的数据插入删除，还是不断新增数据。 基于链表，可以实现多种数据结构，如队列，栈，树等。 本章节就来分享一下链表的形式。
实用单向链表的基本操作函数24个C语言版
03-23
在这个C语言实现的案例中，我们有24个不同的函数，用于执行单向链表的各种基础操作。下面将详细介绍这些操作以及它们在实际编程中的作用。 1. **创建链表**：初始化链表通常涉及到创建一个空头节点，它不存储任何...
内核链表，链式栈，队列的学习实现
KLh
04-13 170
一、链表的种类。 传统链表： 单向链表、单向循环链表、双向链表、双向循环链表。 非传统链表： 内核链表。 传统链表与非传统链表区别？ 传统链表增删改查，都是需要自己实现。 非传统链表增删改查，都是由内核提供，都已经实现好的了，我们只需要直接调用即可。 二、什么是内核链表？ 内核链表与传统链表不一样，传统链表数据域与指针域都是用户自己写的，但是内核链表数据域是用户自己写的，但是指针域是内核链表已经实现好的了，用户不能修改指针域。 内核链表本身就是一条双向循环链表，头节点无效，但是与双向循环链表模型不一样。
linux内核之双向循环链表
weixin_44235286的博客
10-30 895
list内核链表操作
C语言中单向循环链表与双向循环链表详解
qq_41835250的博客
07-26 5251
每日一句 It’s gonna be ok. 一切都会好的。 内容概要 单向循环链表 首先来看看图示： 图展示的是一个单向循环链表，他跟以上的单向链表对比只是多了一个指向头结点的 指针，因此，他们的算法几乎是一样的。 第一，设计节点。 单向循环链表的节点跟单向链表完全一致。 第二，初始化空链表。 跟单向链表类似，我们既可以初始化一个带有头结点的空循环链表，也可以不要头结点： 这边把两个步骤放在一起了 linklist init_list(void) // 带有头结点的单循环链表 { linklis
从头详细了解单链表、双向链表，循环链表的构建及操作【c++】
weixin_60634144的博客
05-15 1148
目录 引入 单链表 创建链表的准备 链表的创建 链表的插入 链表的删除 举例 插入节点、按数据删除节点、打印链表数据 的代码实现 双向链表 循环链表 引入 自引用结构体： 即在结构体中包含了一个指向与其类型相同的结构体的指针成员。例如下面的例子： struct node{ int data; struct node* nextPtr } 定义了一个 struct node ，其中包含一个数据成员 data 和一个指针成员 nextPtr，而nextPt.
数据结构篇——链表操作的实现（单向/双向链表，单向/双向循环链表）！
jjq20020211的博客
07-26 1071
本文介绍了单向链表、双向链表、单向循环链表以及双向循环链表，并附有完整代码！
【Linux内核链表】的原理及使用方式整理
weixin_37620587的博客
04-02 1250
内核的双链表原理以及使用方式，包括内核的链表宏解释
第二十四篇，内核链表，链式栈，队列的相关操作。
weixin_44651073的博客
03-02 269
一、链表的种类。 1、传统链表一共有4种，分别是单向/单向循环/双向/双向循环链表。 因为这些链表增删改查过程都是用户自己设计的，所以称之为传统链表。 2、非传统链表只有1种，就是内核链表。 因为内核链表的增删改查已经写好了，用户只需要直接调用即可。 优点：用户只需要直接调用即可，不需要关心实现过程。 缺点：用户不能修改函数接口。 二、什么是内核链表？ 1、内核链表本身就是一条双向循环链表。 2、内核链表头节点依然是无效。 3、内核链表数据域是由用户自己设计，指针域虽然也是跟双向循环链表一样，有一个前驱
【Kernel】内核数据结构之链表（v5.15.10）
qq_40392981的博客
02-22 594
【Kernel】内核数据结构之链表（v5.15.10） 内核源码快捷查看 一、概念与特点 链表是一种存放和操作可变数量元素（节点）的数据结构。 元素动态创建并插入链表 无需占用连续存储区 二、单向链表、双向链表、环形链表 单向链表：数据域 + 后向指针 双向链表：数据域 + 前向指针 +后向指针 环形链表：在单向链表OR双向链表基础上，对头尾指针进行修改，使链表成环。 三、内核链表：list_head list_head 结构体定义，/inclue/linux/types.h 如下 stru
c语言 链表 双向链表 双向循环链表
02-26
双向链表与单向链表相比，具有更灵活的操作特性，而双向循环链表则在此基础上增加了循环的特性，使得遍历和操作更加方便。 首先，让我们理解双向链表的基本概念。双向链表中的每个节点包含三个部分：数据域、前向...
深入浅出linux内核源代码之双向链表list_head(list.h).pdf
03-31
与单向链表相比，双向链表的每个节点不仅包含指向下一个节点的指针，还包含一个指向前一个节点的指针，从而提供更灵活的访问和操作方式。 在Linux内核中，`list.h`头文件定义了双向链表的核心结构——`struct list_...
数据结构之LRUCache
我要学编程的博客
08-22 1130
LRU Cache 的概念、模拟实现、相关练习
数据结构-时间、空间复杂度-详解
2401_86587256的博客
08-23 1207
数据结构-时间、空间复杂度-详解
排序------快速排序（C语言实现）
markingyi的博客
08-25 856
讲解快速排序原理，并通过例题使用C语言实现。
八股总结-----C++、数据结构、算法
m0_48022770的博客
08-25 355
存储可执行代码（程序指令）。：存储全局变量和静态变量（已初始化和未初始化）。：用于动态内存分配，由程序员管理。：存储函数调用中的局部数据（局部变量、参数、返回地址）。
Linux 数据结构 链表
最新发布
mxyzhy的博客
08-28 249
单向链表操作
【初阶数据结构】顺序表和链表算法题（上）
2301_81072404的博客
08-22 742
数据结构与算法—顺序表链表篇
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值