单向链表的操作

最新推荐文章于 2024-10-05 15:32:05 发布
最新推荐文章于 2024-10-05 15:32:05 发布
阅读量140 收藏
点赞数 1
文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43344188/article/details/141649210
版权

单向链表操作：
    基本操作：
    1.创建
    2.销毁
    3.插入 
    4.删除
    5.打印
    6.修改
    7.查询

#include "linklist.h"

//创建空链表
LinkNode *CreateLinkList(void)
{   
    LinkNode *pTmpNode = NULL;

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

    pTmpNode->Data = 0;
    pTmpNode->pNext = NULL;

    return pTmpNode;
}

//头插法
int HeadInsertLinkList(LinkNode *pHead, DataType TmpData)
{
    LinkNode *pTmpNode = NULL;

    //1.申请空间
    pTmpNode = malloc(sizeof(LinkNode));
    if (NULL == pTmpNode)
    {
        return -1;
    }

    //2.将Data成员初始化
    pTmpNode->Data = TmpData;

    //3.将pNext成员初始化(和后面连起来)
    pTmpNode->pNext = pHead->pNext;

    //4.将头结点的pNext指向新申请节点(和前面连起来)
    pHead->pNext = pTmpNode;

    return 0;
}

//遍历
int ShowLinkList(LinkNode *pHead)
{
    LinkNode *pTmpNode = NULL;

    pTmpNode = pHead->pNext;
    while (pTmpNode != NULL)
    {
        printf("%d ", pTmpNode->Data);
        pTmpNode = pTmpNode->pNext;
    }
    printf("\n");

    return 0;
}

//修改
int UpdateLinkList(LinkNode *pHead, DataType OldData, DataType NewData)
{
    LinkNode *pTmpNode = NULL;
    int cnt = 0;

    pTmpNode = pHead->pNext;
    while (pTmpNode != NULL)
    {
        if (pTmpNode->Data == OldData)
        {
            pTmpNode->Data = NewData;
            cnt++;
        }
        pTmpNode = pTmpNode->pNext;
    }

    return cnt;
}

//查找
LinkNode *FindLinkList(LinkNode *pHead, DataType TmpData)
{
    LinkNode *pTmpNode = NULL;

    pTmpNode = pHead->pNext;
    while (pTmpNode != NULL)
    {
        if (pTmpNode->Data == TmpData)
        {
            return pTmpNode;
        }
        pTmpNode = pTmpNode->pNext;
    }

    return NULL;
}

//尾插
int TailInsertLinkList(LinkNode *pHead, DataType TmpData)
{
    LinkNode *pNewNode = NULL;
    LinkNode *pTmpNode = NULL;

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

    pNewNode->Data = TmpData;
    pNewNode->pNext = NULL;

    pTmpNode = pHead;
    while (pTmpNode->pNext != NULL)
    {
        pTmpNode = pTmpNode->pNext;
    }

    pTmpNode->pNext = pNewNode;

    return 0;
}

//删除链表节点
int DeleteLinkList(LinkNode *pHead, DataType TmpData)
{
    LinkNode *pPreNode = NULL;
    LinkNode *pTmpNode = NULL;
    int cnt = 0;

    pPreNode = pHead;
    pTmpNode = pHead->pNext;
    while (pTmpNode != NULL)
    {
        if (pTmpNode->Data == TmpData)
        {
            //删除
            pPreNode->pNext = pTmpNode->pNext;
            free(pTmpNode);
            pTmpNode = pPreNode->pNext;
            cnt++;
        }
        else 
        {
            pTmpNode = pTmpNode->pNext;
            pPreNode = pPreNode->pNext;
        }
    }

    return cnt;
}

//销毁链表节点
int DestroyLinkList(LinkNode **ppHead)
{
    LinkNode *pTmpNode = NULL;
    LinkNode *pFreeNode = NULL;

    pTmpNode = pFreeNode = *ppHead;
    while (pTmpNode != NULL)
    {
        pTmpNode = pTmpNode->pNext;
        free(pFreeNode);
        pFreeNode = pTmpNode;
    }
    *ppHead = NULL;

    return 0;
}

//找到中间节点位置
//算法：
//  快指针pFast每次走2步
//  慢指针pSlow每次走1步
//  快指针到达末尾时，慢指针所在的位置即为中间位置
LinkNode *FindMidLinkNode(LinkNode *pHead)
{
    LinkNode *pFast = NULL;
    LinkNode *pSlow = NULL;

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

        pSlow = pSlow->pNext;
    }

    return pSlow;
}

//找到链表倒数第k个节点
//算法：
//  快指针先走k步
//  慢指针和快指针每次走1步(快指针总是领先慢指针k步)
//  当快指针走到末尾时,慢指针即指向链表倒数第k个节点
LinkNode *FindLastKthLinkNode(LinkNode *pHead, int k)
{
    LinkNode *pFast = pHead->pNext;
    LinkNode *pSlow = pHead->pNext;
    int i = 0;

    for (i = 0; i < k; i++)
    {
        pFast = pFast->pNext;
        if (NULL == pFast)
        {
            break;
        }
    }

    if (NULL == pFast)
    {
        return NULL;
    }

    while (pFast != NULL)
    {
        pSlow = pSlow->pNext;
        pFast = pFast->pNext;
    }

    return pSlow;
}

//倒置链表
int ReversalLinkList(LinkNode *pHead)
{
    LinkNode *pTmpNode = NULL;
    LinkNode *pInsertNode = NULL;

    pTmpNode = pHead->pNext;
    pHead->pNext = NULL;
    pInsertNode = pTmpNode;

    while (pTmpNode != NULL)
    {
        pTmpNode = pTmpNode->pNext;
        pInsertNode->pNext = pHead->pNext;
        pHead->pNext = pInsertNode;
        pInsertNode = pTmpNode;
    }

    return 0;
}

//链表排序（冒泡排序法）
int BubbleSortLinkList(LinkNode *pHead)
{   
    LinkNode *pTmpNode1 = NULL;
    LinkNode *pTmpNode2 = NULL;
    LinkNode *pEnd = NULL;
    DataType TmpData;

    //如果链表没有节点或者只有1个节点返回0 
    if (NULL == pHead->pNext || NULL == pHead->pNext->pNext)
    {
        return 0;
    }

    while (1)
    {
        pTmpNode1 = pHead->pNext;
        pTmpNode2 = pHead->pNext->pNext;
        if (pTmpNode2 == pEnd)
        {
            break;
        }

        while (pTmpNode2 != pEnd)
        {
            if (pTmpNode1->Data > pTmpNode2->Data)
            {
                TmpData = pTmpNode1->Data;
                pTmpNode1->Data = pTmpNode2->Data;
                pTmpNode2->Data = TmpData;
            }
            pTmpNode1 = pTmpNode1->pNext;
            pTmpNode2 = pTmpNode2->pNext;
        }
        pEnd = pTmpNode1;
    }
    
    return 0;
}

//选择排序
int SelectSortLinkList(LinkNode *pHead)
{
    LinkNode *pTmpNode = NULL;
    LinkNode *pMinNode = NULL;
    LinkNode *pSwapNode = NULL;
    DataType TmpData;

    if (NULL == pHead->pNext)
    {
        return 0;
    }

    pSwapNode = pHead->pNext;

    while (pSwapNode->pNext != NULL)
    {
        pMinNode = pSwapNode;
        pTmpNode = pSwapNode->pNext;
        while (pTmpNode != NULL)
        {
            if (pTmpNode->Data < pMinNode->Data)
            {
                pMinNode = pTmpNode;
            }
            pTmpNode = pTmpNode->pNext;
        }
        if (pMinNode != pSwapNode)
        {
            TmpData = pMinNode->Data;
            pMinNode->Data = pSwapNode->Data;
            pSwapNode->Data = TmpData;
        }
        pSwapNode = pSwapNode->pNext;
    } 

    return 0;
}

    复杂操作：
    1.查找链表中间节点
    2.查找链表倒数第k个节点
    3.链表的倒置(反转)
    4.链表的排序(冒泡排序、选择排序)
    5.已知链表中间某个节点地址，不知道头结点地址，如何删除该节点
    6.如何判断一个链表是否有环？环长？环的入口位置？
        是否有环：快指针每次走2步,慢指针每次走1步,快慢指针相遇则说明有环
        如何计算环长：标记相遇的位置，让指针继续向后走，没走一步计算器自加,走回到标记位置，则计算器值即为环长
        如何计算环入口位置：将一个指针从第一个节点向后走，将一个指针从相遇点向后走，两个指针相遇的位置即为环入口的位置

#include "linklist.h"

//创建空链表
LinkNode *CreateLinkList(void)
{   
    LinkNode *pTmpNode = NULL;

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

    pTmpNode->Data = 0;
    pTmpNode->pNext = NULL;

    return pTmpNode;
}

//头插法
int HeadInsertLinkList(LinkNode *pHead, DataType TmpData)
{
    LinkNode *pTmpNode = NULL;

    //1.申请空间
    pTmpNode = malloc(sizeof(LinkNode));
    if (NULL == pTmpNode)
    {
        return -1;
    }

    //2.将Data成员初始化
    pTmpNode->Data = TmpData;

    //3.将pNext成员初始化(和后面连起来)
    pTmpNode->pNext = pHead->pNext;

    //4.将头结点的pNext指向新申请节点(和前面连起来)
    pHead->pNext = pTmpNode;

    return 0;
}

//遍历
int ShowLinkList(LinkNode *pHead)
{
    LinkNode *pTmpNode = NULL;

    pTmpNode = pHead->pNext;
    while (pTmpNode != NULL)
    {
        printf("%d ", pTmpNode->Data);
        pTmpNode = pTmpNode->pNext;
    }
    printf("\n");

    return 0;
}

//修改
int UpdateLinkList(LinkNode *pHead, DataType OldData, DataType NewData)
{
    LinkNode *pTmpNode = NULL;
    int cnt = 0;

    pTmpNode = pHead->pNext;
    while (pTmpNode != NULL)
    {
        if (pTmpNode->Data == OldData)
        {
            pTmpNode->Data = NewData;
            cnt++;
        }
        pTmpNode = pTmpNode->pNext;
    }

    return cnt;
}

//查找
LinkNode *FindLinkList(LinkNode *pHead, DataType TmpData)
{
    LinkNode *pTmpNode = NULL;

    pTmpNode = pHead->pNext;
    while (pTmpNode != NULL)
    {
        if (pTmpNode->Data == TmpData)
        {
            return pTmpNode;
        }
        pTmpNode = pTmpNode->pNext;
    }

    return NULL;
}

//尾插
int TailInsertLinkList(LinkNode *pHead, DataType TmpData)
{
    LinkNode *pNewNode = NULL;
    LinkNode *pTmpNode = NULL;

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

    pNewNode->Data = TmpData;
    pNewNode->pNext = NULL;

    pTmpNode = pHead;
    while (pTmpNode->pNext != NULL)
    {
        pTmpNode = pTmpNode->pNext;
    }

    pTmpNode->pNext = pNewNode;

    return 0;
}

//删除链表节点
int DeleteLinkList(LinkNode *pHead, DataType TmpData)
{
    LinkNode *pPreNode = NULL;
    LinkNode *pTmpNode = NULL;
    int cnt = 0;

    pPreNode = pHead;
    pTmpNode = pHead->pNext;
    while (pTmpNode != NULL)
    {
        if (pTmpNode->Data == TmpData)
        {
            //删除
            pPreNode->pNext = pTmpNode->pNext;
            free(pTmpNode);
            pTmpNode = pPreNode->pNext;
            cnt++;
        }
        else 
        {
            pTmpNode = pTmpNode->pNext;
            pPreNode = pPreNode->pNext;
        }
    }

    return cnt;
}

//删除链表节点
int DestroyLinkList(LinkNode **ppHead)
{
    LinkNode *pTmpNode = NULL;
    LinkNode *pFreeNode = NULL;

    pTmpNode = pFreeNode = *ppHead;
    while (pTmpNode != NULL)
    {
        pTmpNode = pTmpNode->pNext;
        free(pFreeNode);
        pFreeNode = pTmpNode;
    }
    *ppHead = NULL;

    return 0;
}

//找到中间节点位置
//算法：
//  快指针pFast每次走2步
//  慢指针pSlow每次走1步
//  快指针到达末尾时，慢指针所在的位置即为中间位置
LinkNode *FindMidLinkNode(LinkNode *pHead)
{
    LinkNode *pFast = NULL;
    LinkNode *pSlow = NULL;

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

        pSlow = pSlow->pNext;
    }

    return pSlow;
}

//找到链表倒数第k个节点
//算法：
//  快指针先走k步
//  慢指针和快指针每次走1步(快指针总是领先慢指针k步)
//  当快指针走到末尾时,慢指针即指向链表倒数第k个节点
LinkNode *FindLastKthLinkNode(LinkNode *pHead, int k)
{
    LinkNode *pFast = pHead->pNext;
    LinkNode *pSlow = pHead->pNext;
    int i = 0;

    for (i = 0; i < k; i++)
    {
        pFast = pFast->pNext;
        if (NULL == pFast)
        {
            break;
        }
    }

    if (NULL == pFast)
    {
        return NULL;
    }

    while (pFast != NULL)
    {
        pSlow = pSlow->pNext;
        pFast = pFast->pNext;
    }

    return pSlow;
}

//倒置链表
int ReversalLinkList(LinkNode *pHead)
{
    LinkNode *pTmpNode = NULL;
    LinkNode *pInsertNode = NULL;

    pTmpNode = pHead->pNext;
    pHead->pNext = NULL;
    pInsertNode = pTmpNode;

    while (pTmpNode != NULL)
    {
        pTmpNode = pTmpNode->pNext;
        pInsertNode->pNext = pHead->pNext;
        pHead->pNext = pInsertNode;
        pInsertNode = pTmpNode;
    }

    return 0;
}

//链表排序（冒泡排序法）
int BubbleSortLinkList(LinkNode *pHead)
{   
    LinkNode *pTmpNode1 = NULL;
    LinkNode *pTmpNode2 = NULL;
    LinkNode *pEnd = NULL;
    DataType TmpData;

    //如果链表没有节点或者只有1个节点返回0 
    if (NULL == pHead->pNext || NULL == pHead->pNext->pNext)
    {
        return 0;
    }

    while (1)
    {
        pTmpNode1 = pHead->pNext;
        pTmpNode2 = pHead->pNext->pNext;
        if (pTmpNode2 == pEnd)
        {
            break;
        }

        while (pTmpNode2 != pEnd)
        {
            if (pTmpNode1->Data > pTmpNode2->Data)
            {
                TmpData = pTmpNode1->Data;
                pTmpNode1->Data = pTmpNode2->Data;
                pTmpNode2->Data = TmpData;
            }
            pTmpNode1 = pTmpNode1->pNext;
            pTmpNode2 = pTmpNode2->pNext;
        }
        pEnd = pTmpNode1;
    }
    
    return 0;
}

//选择排序
int SelectSortLinkList(LinkNode *pHead)
{
    LinkNode *pTmpNode = NULL;
    LinkNode *pMinNode = NULL;
    LinkNode *pSwapNode = NULL;
    DataType TmpData;

    if (NULL == pHead->pNext)
    {
        return 0;
    }

    pSwapNode = pHead->pNext;

    while (pSwapNode->pNext != NULL)
    {
        pMinNode = pSwapNode;
        pTmpNode = pSwapNode->pNext;
        while (pTmpNode != NULL)
        {
            if (pTmpNode->Data < pMinNode->Data)
            {
                pMinNode = pTmpNode;
            }
            pTmpNode = pTmpNode->pNext;
        }
        if (pMinNode != pSwapNode)
        {
            TmpData = pMinNode->Data;
            pMinNode->Data = pSwapNode->Data;
            pSwapNode->Data = TmpData;
        }
        pSwapNode = pSwapNode->pNext;
    } 

    return 0;
}

//判断链表是否有环
//实现方式：
//     快指针每次走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;
}


    

qq_43344188
关注
单向链表实现
hxy1625309592的博客
12-15 837
1.1 基本介绍 链表(linked list)是一种在物理上非连续、非顺序的数据结构，由若干节点（node）所组成。链表中数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域(data)，另一个是存储下一个结点地址的指针域(next)。（百度百科） 1.2 存储原理 链表的每一个节点分布在内存的不同位置，依靠next指针关联起来。这样可以灵活有效地利用零散的碎片空间。链表的第1个
单向链表操作类模板实现代码
09-19
单向链表操作类模板实现代码，代码内包含结点类、链表操作类的实现以及主测试函数等；其中链表操作包含结点插入、删除、获取等；
Python单向链表操作
分享一点有用的知识
04-21 775
Python单向链表操作
单向链表操作的实现（验证性实验）
weixin_51877075的博客
10-04 696
单向链表操作的实现（验证性实验） 1. 需求分析 单向链表是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指向列表中的下一个结点。基本操作包括：生成链表，添加节点，返回节点，删除节点，查找结点，遍历链表。 （1) 输入的形式和输入值的范围：程序是按照数字选择对应功能的，各项功能中，除了退出程序，其他功能都要输入一个int型数字，输出的数字也为整数。 （2) 输出的形
单向链表操作
qq_47357951的博客
05-07 128
【代码】单向链表操作。
c++实现单向链表
henjdx的博客
03-26 1125
单向链表属于链表中的一类，链表是用于数据元素的线性集合，其中每个元素都指向下一个元素，元素存储上并不连续。单向链表的特性是每个元素只知道其下一个元素是谁。
单向链表操作规则
sc1234_的博客
07-30 514
原文链接：https://blog.csdn.net/zjj_flower/article/details/131481732。循环链表：通常链表的尾结点的 next 指针都是 null，但是对于循环链表，尾结点的 next 指针指向头结点。链表中每一个元素都是指向下一个元素的，在内存中，地址空间是不连续的。插入或者删除性能：找到插入点O(n) + 插入操作O(1) = O(n)单向链表：每一个元素只知道下一个元素是谁，不知道上一个元素。双向链表：每一个节点元素都知道自己的上一个元素和下一个元素。
单向链表的基本操作
weixin_52358343的博客
09-29 838
链表通常是单向链表，它包含多个结点，每个结点有一个指向后继元素的next（下一个）指针。表中最后一个结点的next指针为NULL，表示该链表结束。 链表的类型声明： public class ListNode { private int data; private ListNode next; public ListNode(int data) { this.data = data; } public in...
c语言单向链表操作
lyeffort的博客
11-21 370
c语言单向链表操作
单向链表的简单实现
a1748400316f的博客
03-11 1593
首先我们先了解 链表的概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 * 链表与顺序表的不同*：链表是存储的数据不是连续的，比起顺序表节省空间(顺序表realloc可能开辟太多空间，而导致浪费而链表则是需要则开辟一块空间避免了这个问题)。【现在我们进入单链表的实现与学习】 单向链表的物理结构： *链表的逻辑结构*： typedef int SLdatatype; typedef struct Slistnode { SLdataty.
C语言——单向链表
2301_79695216的博客
07-21 753
线性表的链式存储结构，我们叫做链表。将线性表L=(a0,a1,……,an-1)中各元素分布在存储器中的不同存储区域，线性表中的各元素称为结点，通过地址或指针建立结点之间的联系，所得到的存储结构为链表 结构。
用C++类实现单向链表的增删查和反转操作方法
08-30
通过以上的步骤，我们可以实现一个完整的单向链表操作类，包括创建、插入、删除、查找和反转功能。这种实现方式对于学习C++和数据结构的初学者来说，既直观又易于理解。在实践中，不断挑战自己，不断犯错并纠正，是...
单向链表类模板_单向链表类模板_fastchq_
10-03
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在C++编程中，为了实现通用性，我们通常会使用模板类来创建单向链表，以便它可以处理不同类型的元素。标题"单向链表类...
C语言实现单向链表及操作
03-24
数据结构，c语言实现的单向链表。代码分享 struct LinkNode { int data; struct LinkNode *next; }; typedef struct LinkNode *Lnode;
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 370
【代码】数据结构-线性表-课设实验-手机销售。
【数据结构】双向链表（Doubly Linked List）
最新发布
2301_77727857的博客
10-05 264
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 347
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
动态顺序表的增删改查（数据结构）
m0_62048999的博客
09-28 1213
顺序表是数据结构的基础知识，通过学习次内容，可以让我们了解顺序表中数据中是如何进行存储，删除，插入数据的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值