大话数据结构（C++版）链表

已于 2023-11-01 21:24:42 修改
阅读量107 收藏
点赞数 1
分类专栏： C++ 数据结构 文章标签： 数据结构 c++ 链表
于 2023-10-08 10:38:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73579869/article/details/133671122
版权

基础知识

单链表有两种实现方式，带头结点和不带头结点

每个结点除了存放数据元素外，还要存储指向下一个结点的指针

顺序表优点：可随机存储，存储密度高

           缺点：要求大片连续空间，改变容量不方便

单链表优点：不要求大片连续空间，改变容量方便

           缺点：不可随机存取，要耗费一定空间存放指针

前提代码

#include <iostream>
using namespace std;

#define MAXSIZE 20 // 存储空间初始分配量 

typedef int ElemType;

struct Node
{
    ElemType data; //每个结点存放一个数据元素
    Node* next;  //表示指向下一个节点的指针
};

typedef Node* LinkList;  //Node*表示指向Node结构体的指针类型，而LinkList是用来代表这个指针类型的别名。

打印整数

 bool visit(ElemType c)
{
    cout << c;
    return true;
}

初始化链式线性表

bool InitList(LinkList *L) 
{ 
    //*L=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */
    *L = new Node;  //用于创建一个新的节点，并将该节点的地址赋值给指针变量*L，即链表的头节点指针。
    if (!(*L)) /* 存储分配失败 */
        return 0;
    (*L)->next = NULL; /* 指针域为空 */

    return true;
}
//if (!(*L)) 检查 *L 是否为 NULL。如果 *L 是 NULL，那么 !(*L) 就为 true，if 语句中的代码块就会被执行。如果 *L 不是 NULL，那么 !(*L) 就为 false，if 语句中的代码块就不会被执行。

带头结点更方便

检查是否空表

#include <iostream>
using namespace std;

typedef int ElemType;  // 假设链表节点的数据类型为int

struct Node
{
    ElemType data;
    Node* next;
};

typedef Node* LinkList;  // 定义链表类型
bool InitList(LinkList* L)
{
    *L = new Node;
    if (!(*L))
        return false;
    (*L)->next = nullptr;
    
    return true;
}

bool ListEmpty(LinkList L)
{
    if (L->next)
        return false;
    else
        return true;
}

int main()
{
    LinkList L;
    InitList(&L);

    if (ListEmpty(L))
        cout << "The list is empty." << endl;
    else
        cout << "The list is not empty." << endl;

    return 0;
}

重置空表

bool ClearList(LinkList* L)
{
    LinkList p, q;
    p = (*L)->next;  // p指向第一个节点

    while (p)  //这个循环条件表示只要p指向的节点不为空，即链表还有节点需要释放，就继续执行循环。
    {
        q = p->next;  //将下一个节点的指针保存到临时指针变量q中，以便在释放当前节点后能够访问到下一个节点。
        delete p;  // 使用delete操作符释放当前节点p的内存空间，即释放节点所占用的内存。
        p = q;  //将指针p移动到下一个节点，即将p指向q所指向的节点，以便在下一次循环中处理下一个节点。
    }//通过这个循环，可以逐个释放链表中的节点，直到链表为空

    (*L)->next = NULL;  // 头节点的指针域置为空

    return true;  // 返回操作成功
}
//p和q是临时指针变量，用于遍历链表节点。
//p指向链表的第一个节点，即头节点的下一个节点。
//使用while循环遍历链表，直到遍历到链表尾部，即p为NULL。
//在循环中，首先将下一个节点的指针保存到q中，然后使用delete释放当前节点p的内存空间。

返回L中数据元素个数

int ListLength(LinkList L)
{
    int i = 0;
    LinkList p = L->next; /* p指向第一个结点 */

    while(p)                        
    {
        i++;
        p = p->next;
    }

    return i;
}

用e返回L中第i个数据元素的值(按位查找)

bool GetElem(LinkList L,int i,ElemType *e)
{
	int j;
	LinkList p;		/* 声明一结点p */
	p = L->next;		/* 让p指向链表L的第一个结点 */
	j = 1;		/*  j为计数器 */

	while (p && j<i)  /* p不为空或者计数器j还没有等于i时，循环继续 */
	{   
		j++;
        p = p->next;  /* 让p指向下一个结点 */		
	}

	if ( !p || j>i ) 
		return 0;  /*  第i个元素不存在 */
	*e = p->data;   /*  取第i个元素的数据 */

	return true;
}

返回L中第1个与e满足关系的数据元素的位序(按值查找)

#include <iostream>
using namespace std;

struct LNode
{
    int data;
    LNode* next;
};

int LocateElem(LNode* L, int e)
{
    int i = 0;
    LNode* p = L->next;

    while (p)
    {
        i++;
        if (p->data == e)  /* 找到这样的数据元素 */
            return i;
        p = p->next;
    }

    return 0;  // 未找到指定元素，返回0
}

int main()
{
    // 创建链表
    LNode* L = new LNode;
    L->next = nullptr;

    // 在链表中插入一些元素
    for (int i = 1; i <= 5; i++)
    {
        LNode* newNode = new LNode;
        newNode->data = i;
        newNode->next = L->next;
        L->next = newNode;
    }

    // 查找元素位置并输出结果
    int position = LocateElem(L, 3);
    if (position != 0)
        cout << "元素3的位置是：" << position << endl;
    else
        cout << "未找到元素3" << endl;

    // 释放链表节点的内存
    LNode* p = L;
    while (p)
    {
        LNode* temp = p;
        p = p->next;
        delete temp;
    }

    return 0;
}

在L中第i个位置之后插入新的数据元素e，L的长度加1

bool ListInsert(LinkList *L,int i,ElemType e)
{ 
	int j;
	LinkList p,s;
	p = *L;   
	j = 1;
//将指向链表头节点的指针 *L 赋值给指针 p。这样做是为了在后续的代码中使用指针 p 来遍历链表。
	while (p && j < i)     /* 寻找第i个结点 */
	{
		p = p->next;
		++j;
	} 

	if (!p || j > i) 
		return 0;   /* 第i个元素不存在 */
	//s = (LinkList)malloc(sizeof(Node));  /*  生成新结点(C语言标准函数) */
    s = new Node;  //变量s是一个指向链表节点的指针，用于表示要插入的新节点
    //创建了一个新的 Node 类型的节点，并将分配的内存地址赋值给指针 s
	s->data = e;  
	s->next = p->next;    //为了将新节点插入到当前节点p之后
	p->next = s;          //为了将新节点插入到链表中，使其成为当前节点p的后继节点。

	return true;
}

前插就是后插再交换

删除L的第i个数据元素，并用e返回其值，L的长度减1

bool ListDelete(LinkList *L,int i,ElemType *e) 
{ 
	int j;
	LinkList p,q;
	p = *L;
	j = 1;

	while (p->next && j < i)	/* 遍历寻找第i个元素 */
	{
        p = p->next;
        ++j;
	}

	if (!(p->next) || j > i) 
	    return false;           /* 第i个元素不存在 */

	q = p->next;  //保存要删除的节点，以便后续操作。
	p->next = q->next;			//跳过节点 q，将链表重新连接起来，实现了删除节点的操作。
	//在链表中，每个节点都有一个指针 next 指向下一个节点。当我们要删除节点 q 时，
    //我们需要将 q 的前一个节点的 next 指针指向 q 的后一个节点，即跳过节点 q。
    *e = q->data;               /* 将q结点中的数据给e */
	free(q);                    /* 让系统回收此结点，释放内存 */

	return true;
}

依次对L的每个数据元素输出

bool ListTraverse(LinkList L)
{
    LinkList p = L->next;

    while(p)
    {
        visit(p->data);
        p = p->next;
    }

    cout<<endl;

    return 1;
}

随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） 

void CreateListHead(LinkList *L, int n) 
{
	LinkList p;
	int i;

	srand(time(0));                         // 初始化随机数种子 
	//*L = (LinkList)malloc(sizeof(Node));
    *L = new Node;
	(*L)->next = NULL;                      //  先建立一个带头结点的单链表 

	for (i = 0; i < n; i++) 
	{
		//p = (LinkList)malloc(sizeof(Node)); //  生成新结点 
        p = new Node;
		p->data = rand()%100+1;             //  随机生成100以内的数字 
		p->next = (*L)->next;    
		(*L)->next = p;						//  插入到表头 
	}
}

随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） 

void CreateListTail(LinkList *L, int n) 
{
	LinkList p,r;
	int i;
	srand(time(0));                      // 初始化随机数种子 
	//*L = (LinkList)malloc(sizeof(Node)); // L为整个线性表 
    *L = new Node; //创建一个头节点，并将其地址赋值给 L 指针，即将链表的头指针指向头节点。
	r = *L;                           //将 r 指针指向头节点，用于记录链表的尾部。
	
    for(i = 0;i < n;i++)
    {
	    //p = (Node *)malloc(sizeof(Node)); //  生成新结点 
        p = new Node;   //创建一个新节点 p
        p->data = rand()%100+1;    //为新节点的数据域赋值，生成一个介于 1 到 100 之间的随机数。
	    r->next = p;               //将新节点 p 连接到链表的尾部
	    r = p;                // 更新 r 的值为 p 的意思是将指针 r 移动到指针 p 所指向的位置
	}
	r->next = NULL;                       // 表示当前链表结束 
}

int main()
{
    LinkList L;
    ElemType e;
    Status i;
    int j, k;
    i = InitList(&L);
    cout << "初始化L后：ListLength(L)=" << ListLength(L) << endl;
    for (j = 1; j <= 5; j++)
        i = ListInsert(&L, 1, j);
    cout << "在L的表头依次插入1～5后：L.data=";
    ListTraverse(L);

    cout << "ListLength(L)=" << ListLength(L) << endl;
    i = ListEmpty(L);
    cout << "L是否空：i=" << i << "(1:是 0:否)" << endl;

    i = ClearList(&L);
    cout << "清空L后：ListLength(L)=" << ListLength(L) << endl;
    i = ListEmpty(L);
    cout << "L是否空：i=" << i << "(1:是 0:否)" << endl;

    for (j = 1; j <= 10; j++)
        ListInsert(&L, j, j);
    cout << "在L的表尾依次插入1～10后：L.data=";
    ListTraverse(L);

    cout << "ListLength(L)=" << ListLength(L) << endl;

    ListInsert(&L, 1, 0);
    cout << "在L的表头插入0后：L.data=";
    ListTraverse(L);
    cout << "ListLength(L)=" << ListLength(L) << endl;

    GetElem(L, 5, &e);
    cout << "第5个元素的值为：" << e << endl;
    for (j = 3; j <= 4; j++)
    {
        k = LocateElem(L, j);
        if (k)
            cout << "第" << k << "个元素的值为" << j << endl;
        else
            cout << "没有值为" << j << "的元素" << endl;
    }

    k = ListLength(L); /* k为表长 */
    for (j = k + 1; j >= k; j--)
    {
        i = ListDelete(&L, j, &e); /* 删除第j个数据 */
        if (i == 0)
            cout << "删除第" << j << "个数据失败" << endl;
        else
            cout << "删除第" << j << "个的元素值为：" << e << endl;
    }
    cout << "依次输出L的元素：";
    ListTraverse(L);

    j = 5;
    ListDelete(&L, j, &e); /* 删除第5个数据 */
    cout << "删除第" << j << "个的元素值为：" << e << endl;

    cout << "依次输出L的元素：";
    ListTraverse(L);

    i = ClearList(&L);
    cout << "\n清空L后：ListLength(L)=" << ListLength(L) << endl;
    CreateListHead(&L, 20);
    cout << "整体创建L的元素(头插法)：";
    ListTraverse(L);

    i = ClearList(&L);
    cout << "\n删除L后：ListLength(L)=" << ListLength(L) << endl;
    CreateListTail(&L, 20);
    cout << "整体创建L的元素(尾插法)：";
    ListTraverse(L);

    return 0;
}


 

静态链表前提代码

#include <cstring>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <ctime>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 1000 /* 存储空间初始分配量 */

typedef int Status;           /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef char ElemType;        /* ElemType类型根据实际情况而定，这里假设为char */


Status visit(ElemType c)
{
    cout << c;
    return OK;
}

/* 线性表的静态链表存储结构 */
struct Component
{
    ElemType data;
    int cur;  //cur：表示指向下一个元素的索引。
};

typedef struct Component StaticLinkList[MAXSIZE];
//静态链表类型名为StaticLinkList，它是一个数组类型，数组的大小由MAXSIZE定义。
//每个元素都是Component类型的结构体，用于表示链表中的节点。

将一维数组space中各分量链成一个备用链表，space[0].cur为头指针，"0"表示空指针

Status InitList(StaticLinkList space) 
{
	int i;
	for (i = 0; i < MAXSIZE-1; i++)  
		space[i].cur = i+1;
	space[MAXSIZE-1].cur = 0; /* 目前静态链表为空，最后一个元素的cur为0 */
	return OK;
}

若备用空间链表非空，则返回分配的结点下标，否则返回0

int Malloc_SSL(StaticLinkList space) 
{ 
	int i = space[0].cur;           		/* 当前数组第一个元素的cur存的值 */
	                                		/* 就是要返回的第一个备用空闲的下标 */
	if (space[0]. cur)         
	    space[0]. cur = space[i].cur;       /* 由于要拿出一个分量来使用了， */
	                                        /* 所以我们就得把它的下一个 */
	                                        /* 分量用来做备用 */
	return i;
}

将下标为k的空闲结点回收到备用链表

void Free_SSL(StaticLinkList space, int k) 
{  
    space[k].cur = space[0].cur;    /* 把第一个元素的cur值赋给要删除的分量cur */
    space[0].cur = k;               /* 把要删除的分量下标赋值给第一个元素的cur */
}

返回L中数据元素个数

int ListLength(StaticLinkList L)
{
    int j = 0;
    int i=L[MAXSIZE-1].cur;
    while(i)
    {
        i = L[i].cur;
        j++;
    }
    return j;
}

在L中第i个元素之前插入新的数据元素e

Status ListInsert(StaticLinkList L, int i, ElemType e)   
{  
    int j, k, l;   
    k = MAXSIZE - 1;   /* 注意k首先是最后一个元素的下标 */
    if (i < 1 || i > ListLength(L) + 1)   
        return ERROR;   
    j = Malloc_SSL(L);   /* 获得空闲分量的下标 */
    if (j)   
    {   
		L[j].data = e;   /* 将数据赋值给此分量的data */
		for(l = 1; l <= i - 1; l++)   /* 找到第i个元素之前的位置 */
		   k = L[k].cur;           
		L[j].cur = L[k].cur;    /* 把第i个元素之前的cur赋值给新元素的cur */
		L[k].cur = j;           /* 把新元素的下标赋值给第i个元素之前元素的ur */
		return OK;   
    }   
    return ERROR;   
}

删除在L中第i个数据元素

Status ListDelete(StaticLinkList L, int i)   
{ 
    int j, k;   
    if (i < 1 || i > ListLength(L))   
        return ERROR;   
    k = MAXSIZE - 1;   
    for (j = 1; j <= i - 1; j++)   
        k = L[k].cur;   
    j = L[k].cur;   
    L[k].cur = L[j].cur;   
    Free_SSL(L, j);   
    return OK;   
}

遍历列表

bool ListTraverse(StaticLinkList L)
{
    int j = 0;
    int i = L[MAXSIZE-1].cur;
    while(i)
    {
        visit(L[i].data);
        i = L[i].cur;
        j++;
    }
    return j;
    cout<<"\n";
    return true;
}

int main()
{
    StaticLinkList L;
    Status i;
    i = InitList(L);
    cout<<"初始化L后：L.length=%d\n",ListLength(L);

    i = ListInsert(L,1,'F');
    i = ListInsert(L,1,'E');
    i = ListInsert(L,1,'D');
    i = ListInsert(L,1,'B');
    i = ListInsert(L,1,'A');

    cout << "\n在L的表头依次插入FEDBA后：\nL.data=";
    ListTraverse(L); 

    i = ListInsert(L,3,'C');
    cout << ("\n在L的“B”与“D”之间插入“C”后：\nL.data=";
    ListTraverse(L); 

    i = ListDelete(L,1);
    cout<<"\n在L的删除“A”后：\nL.data=";
    ListTraverse(L); 

    cout<<"\n";

    return 0;
}

双向链表

双向链表的初始化

双链表的插入



双链表的删除

双链表的遍历

循环链表

循环双链表

误区

int main()
{
	Linklist L;
	Initlist(&L);
	Insertlist(&L, 1, 1);
	Insertlist(&L, 2, 2);
	Insertlist(&L, 3, 3);
	Insertlist(&L, 4, 4);
	cout << L;
}//输出链表的地址并不会打印链表的内容。如果要打印链表的内容，
//可以编写一个遍历链表的函数，并使用该函数输出链表的元素值。

北京理工大学软件工程
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大一下 数据结构 清华严蔚敏(C语言)版 学习记录——链表
http://www.lunatic007.top/
03-04 1022
#include<bits/stdc++.h> #define Status int using namespace std; typedef long long ll; typedef int ElemType; const int maxn=3000; const ll INF=1e18; /* typedef struct item { int expn;//定义数据域的数据类型 }ElemType; */ typedef struct Lnode//定义结点 { .
大话数据结构之链表
老师好，我是安同学
01-04 359
从认识链表到用链表进行CURD！
大话数据结构(二)---链表
努力才会有幸福
06-18 208
文章目录1. 链表1.1 简介1.2 概念1.3 单链表1.3.1. 创建单链表1.3.1. 插入新节点1.3.2. 遍历链表1.3.2. 删除链表1.3.3. 销毁链表1.3.4. 单链表反序1.3.5. 寻找最大元素对1.4. 双链表1.4.1. 双链表的创建1.4.2. 双链表的插入1.4.2. 双链表的删除1.4.2. 双链表的遍历1.4.2. 双链表的销毁2. 队列2.1. 队列简介2.2. 静态队列2.2.1. 创建队列2.2.2. 队列插入2.2.3 求队列长度2.3 链式队列2.3.1.
大话数据结构 - 链表
呵呵
09-25 594
1. 顺序表的缺陷 线性表的顺序存储结构有致命的缺陷, 由于地址的连续性, 插入和删除都需要移动大量的元素; 2. 链表 - 线性表的链式存储结构 链表为了摆脱顺序表的缺陷, 从物理结构上链表各个元素是随机位置, 而不是连续存储; 这样也就导致了每个节点除了存储本身的数据之外还需要存储下一个节点的地址; 这是的插入和删除非常方便, 但是无法像顺序表那样直接获取某个位置的元素, 只能
3
08-21 360
public class NewsDAOHibImpl implements INewsDAO { private HibernateUtil util; public NewsDAOHibImpl() { this.util = HibernateUtil.getInstance(); } @Override public void save(News n) { Sess
数据结构C++链表
03-04
基于C++的数据结构单链表，带主程序可运行，使用头文件可直接编程。
数据结构C++版的双循环链表
07-06
需要使用2013版本以上的Visual Studio才能正常打开 详细的注释说明，代码有点儿乱，能正常运行 C++面向对象
数据结构单双链表c++版
07-14
数据结构单双链表c++版，用devc++软件编写、内部有单双链表数据结构实现代码，增删改查。
数据结构 双向链表（C++）
06-07
数据结构　双向链表的实现
使用C++实现链表数据结构之单链表.zip
最新发布
03-13
链表 使用C++实现链表数据结构之单链表
《大话数据结构》之单链表
艺海拾贝
09-24 562
#define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int Status; typedef int ElemType; #define MAXSIZE 20 typedef struct { ElemType data [MAXSIZE]; int length; }SqList; typedef st
大话数据结构之单链表
dangzhileiqaz的专栏
07-27 651
单链表 线性表的链式存储结构的是用一组任意的存储单元存储线性表的数据元素.这组存储单元可以是连续的,也可以是不连续的. 数据域:存储数据元素信息的域。 指针域：存储直接后继位置的域。 这两部分信息组成数据元素的存储映像,成为节点(Node)。 n 个结点链接成一个链表，即为线性表(a1,a2,a3…….an)的链式存储结构。，有因为此链表的每个结点只含有一个指针域，故称单链表。图(1)
【大话数据结构】单链表
weixin_43878423的博客
08-21 156
单链表接口 public interface IListDS<T> { int GetLength(); //获取长度 void Clear(); //置空表 bool IsEmpty(); //判断表是否为空 void Append(T ite...
大话数据结构笔记3-2：链表
chai471793的博客
04-23 188
静态链表 (游标实现法) 数组描述的链表，每个数组由 data（数据域）存放数据元素和cur（指针域）存放后继元素的下标 组成 第一个和最后一个元素不存数据,第一个元素存放备用链表第一个结点的下标，最后一个元素cur存放第 一个有数值的元素的下标 备用链表 未被使用的数组元素称为备用链表 下图中元素0的cur为7，因为第一个备用链表的下标是7 最后一个元素的cur是1 ，因为第一个不为空的节点...
大话数据结构 —— 顺序表 C#、C++代码实现
TAOTAO
10-24 920
线性结构 定义：线性表是一个线性结构，它是一个含有n≥0个结点的有限序列，对于其中的结点，有且仅有一个开始结点没有前驱但有一个后继结点，有且仅有一个终端结点没有后继但有一个前驱结点，其它的结点都有且仅有一个前驱和一个后继结点。 线性表是最常用且简单的一种数据结构。 一个线性表是n个数据元素的有限序列。 线性表中的数据元素可以是各种各样的，但同一线性表中的元素必定具有相同特性。 在复...
大话数据结构（一）链表的基本操作
panhao762的专栏
03-29 394
#include #include using namespace std;typedef int DataType; //链表元素类型typedef struct node //链表结点{ DataType data; node *next;}LNode,*PLNode;//创建带有头结点的链表//输入ctrl+z结束//有无头结点将会影响到对链表的所有操作，包括显示链表元素、插入、删除、销毁等
《大话数据结构》——学习笔记（图）
benhuo931115的博客
12-20 4640
图图的定义图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，通过表示为：G(V,E)，其中，G表示一个图，V是图G中顶点的集合（有穷非空），E是图G中边的集合（可以为空）图是一种较线性表和树更加复杂的数据结构，在图形结构中，结点之间的关系可以是任意的，图中任意两个数据元素之间都可能相关各种图定义无向边： 若顶点viv_i到vjv_j之间的边没有方向，则称这条边为无向边（Edge），用无序
《大话数据结构》——学习笔记（概述&线性表）
benhuo931115的博客
12-18 2404
数据数据：是描述客观事物的符号，是计算机中可以操作的对象，是能被计算机识别，并输入给计算机处理的符号集合数据元素数据元素：是组成数据的、有一定意义的基本单位，在计算机中通常作为整体处理，也被称为记录数据项数据项：一个数据元素可以由若干个数据项组成，数据项是数据不可分割的最小单位数据对象数据对象：是性质相同的数据元素的集合，是数据的子集数据结构不同数据元素之间不是独立的，而是存在特定的关系，我们将这些
数据结构C++语言链表的基本信息
03-01
链表是一种常见的数据结构，它是由一系列的节点所组成的，每个节点都包含着一个数据元素和一个指向下一个节点的指针。链表可以根据需要动态增长或缩小，因此在编程中非常灵活。 C语言中的链表通常由结构体来定义，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值