【考研-数据结构】线性表

最新推荐文章于 2024-07-15 17:15:24 发布
最新推荐文章于 2024-07-15 17:15:24 发布
阅读量141 收藏
点赞数
分类专栏： 考研-数据结构 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Manner11/article/details/113554344
版权

【考研-数据结构】线性表

1.顺序表

静态空间
//静态顺序表
#include <iostream>
using namespace std;
#define Maxsize 10
typedef struct list {
	int data[Maxsize];
	int length;
}list;
//初始化
void Init(list& l) {
	for (int i = 0; i < Maxsize; i++) {
		l.data[i] = 0;
	}
	l.length = 0;
}
//插入操作
bool list_insert(list& l, int i, int e) {
	if (i<1 || i>l.length + 1) 
		return false;
	if (l.length >= Maxsize) 
		return false;
	for (int j = l.length; j >= i-1; j--) {
		l.data[j + 1] = l.data[j];
	}
	l.data[i - 1] = e;
	l.length++;
	return true;
}
//删除操作
bool list_delete(list& l, int i, int& e) {
	if (i<1 || i>l.length) 
		return false;
	e = l.data[i - 1];
	for (int j = i; j < l.length; j++) {
		l.data[j - 1] = l.data[j];
	}
	l.length--;
	return true;
}
//按位置查找
int list_locate(list& l, int i) {
	if (i<1 || i>l.length) 
		return -1;
	return l.data[i - 1];
}
//按数值查找
int list_search(list& l, int e) {
	for (int j = 0; j < l.length; j++) {
		if (l.data[j] == e) 
			return j+1;
	}
	return 0;
}
//打印顺序表
void list_print(list l) {
	for (int i = 0; i < l.length; i++) {
		cout << l.data[i] << endl;
	}
}
int main() {
	list l;
	int e = -1;
	Init(l);  //初始化
	list_insert(l, 1, 1);  //插入
	list_insert(l, 2, 2);
	list_insert(l, 3, 3);
	list_insert(l, 4, 4);
	list_insert(l, 5, 5);
	int a = list_locate(l, 2);  //按位置查找
	int b = list_search(l, 3);  //按值查找
	list_delete(l, 2,e);  //删除
	list_print(l);
	return 0;
}
动态空间
#include <iostream>
using namespace std;
#define Initsize 10
typedef struct list {
	int *data;
	int Maxsize;
	int length;
}list;
// 初始化
void Init_list(list& l) {
	l.data = new int[10];
	l.length = 0;
	l.Maxsize = Initsize;
}
//扩大最大容量
void add_list_size(list &l, int n) {
	int* p = l.data;
	l.data = new int[l.Maxsize + n];
	for (int i = 0; i < l.length; i++) {
		l.data[i] = p[i];
	}
	l.Maxsize = l.Maxsize + n;
	delete p;
}
//插入操作
bool list_insert(list& l, int i, int e) {
	if (i<1 || i>l.length + 1)
		return false;
	if (l.length >= l.Maxsize)
		return false;
		//add_list_size(l, 1);
	for (int j = l.length; j >= i - 1; j--) {
		l.data[j + 1] = l.data[j];
	}
	l.data[i - 1] = e;
	l.length++;
	return true;
}
//删除操作
bool list_delete(list& l, int i, int& e) {
	if (i<1 || i>l.length)
		return false;
	e = l.data[i - 1];
	for (int j = i; j < l.length; j++) {
		l.data[j - 1] = l.data[j];
	}
	l.length--;
	return true;
}
//按位置查找
int list_locate(list l, int i) {
	if (i<1 || i>l.length)
		return -1;
	return l.data[i - 1];
}
//按数值查找
int list_search(list l, int e) {
	for (int j = 0; j < l.length; j++) {
		if (l.data[j] == e)
			return j + 1;
	}
	return 0;
}
//打印顺序表
void list_print(list l) {
	for (int i = 0; i < l.length; i++) {
		cout << l.data[i] << endl;
	}
}
int main() {
	list l;
	Init_list(l);
	add_list_size(l, 1); 
	list_insert(l, 1, 1);
	list_insert(l, 1, 2);
	list_insert(l, 1, 3);
	list_insert(l, 1, 4);
	list_insert(l, 1, 5);
	list_insert(l, 1, 6);
	list_insert(l, 1, 7);
	list_insert(l, 1, 8);
	list_insert(l, 1, 9);
	list_insert(l, 1, 10);
	list_insert(l, 1, 11);
	list_print(l);
	cout << l.Maxsize<<endl;
	list_insert(l, 12, 12);
	cout << l.Maxsize << endl;
	return 0;
}

2.链表

单链表
//单链表
#include <iostream>
using namespace std;
typedef struct LNode {
	int data;
	LNode* next;
}LNode,*LinkList;
//头插法建立单链表(有头结点)
LinkList List_HeadInsert(LinkList &l) {
	int x;
	LNode* s;
	l = new LNode();
	//l = (LinkList)malloc(sizeof(LNode));
	l->next = NULL;
	cin >> x;
	while (x != 9999) {
		s = new LNode();
		s->data = x;
		s->next = l->next;
		l->next = s;
		cin >> x;
	}
	return l;
}

//头插法建立单链表(没有头结点)
LinkList List_HeadInsert_2(LinkList& l) {
	int x;
	LNode* s;
	cin >> x;
	while (x != 9999) {
		s = new LNode();
		s->data = x;
		s->next = l;
		l = s;
		cin >> x;
	}
	return l;
}

//尾插法建立单链表(有头结点)
LinkList List_TailInsert(LinkList& l) {
	int x;
	l = new LNode();
	LNode* s;
	LNode* r = l;
	cin >> x;
	while (x != 9999) {
		s =new LNode();
		s->data = x;
		r->next = s;
		r = s;
		cin >> x;
	}
	r->next = NULL;
	return l;
}

//尾插法建立单链表(没有头结点)
LinkList List_TailInsert_2(LinkList& l) {
	int x;
	l = new LNode();
	LNode* s;
	LNode* r = l;
	cin >> x;
	if (x != 9999) {
		l = new LNode();
		l->data = x;
	}
	cin >> x;
	while (x != 9999) {
		s = new LNode();
		s->data = x;
		r->next = s;
		r = s;
		cin >> x;
	}
	r->next = NULL;
	return l;
}
//按序号查找结点(有头结点)
LNode* Get_Elem(LinkList l, int i) {
	int j = 1;
	LNode* temp = l->next;  //temp指向第一个结点
	if (i == 0) return l;
	if (i < 0) return nullptr;
	while (j<i&&temp!=nullptr) {
		temp = temp->next;
		j++;
	}
	return temp;  //如果i大于单链表长度，返回nullptr
}
//按结点值查找结点(有头结点)
LNode* Locate_Elem(LinkList l, int e) {
	LNode* temp = l->next;
	while (temp->data != e&&temp!=nullptr) {
		temp = temp->next;
	}
	return temp;
}
//插入结点操作(有头结点)
//另一种方法:使用Get_Elem找到第i个结点，
//           然后在此节点之后插入新节点，
//           最后将此节点与新节点的数据域调换
bool List_Insert(LinkList& l, int i, int e) {
	if (i < 1) return false;
	LNode* re = Get_Elem(l,i - 1);
	LNode* s = new LNode();
	s->data = e;
	s->next = re->next;
	re->next = s;
	return true;
}

//删除结点操作(有头结点)
bool List_Delete(LinkList& l, int i) {
	if (i < 1) return false;
	LNode* re = Get_Elem(l, i - 1);
	LNode* node_i = re->next;
	re->next = node_i->next;
	delete node_i;
	return true;
}

//求单链表表长(有头结点)
int List_length(LinkList l) {
	int len = 0;
	LNode* temp = l->next;
	while (temp != nullptr) {
		temp = temp->next;
		len++;
	}
	return len;
}

//打印单链表
void print(LinkList l) {
	LNode* temp = l->next;
	while (temp != nullptr) {
		cout << temp->data << endl;
		temp = temp->next;
	}
}

int main() {
	LinkList l;
	List_HeadInsert(l);
	// cout << l->next->data<<endl;
	// cout << Get_Elem(l, 2)->data << endl;
	// cout << Locate_Elem(l, 1)->data << endl;
	cout<<List_length(l)<<endl;
	// List_Insert(l, 1, 10);
	// print(l);

	// List_HeadInsert_2(l);
	// cout << l->next->data << endl;

	LinkList t;

	// List_TailInsert(t);
	// cout << t->data << endl;

	// List_TailInsert_2(t);
	// cout << t->data << endl;

	return 0;
}
双链表
#include <iostream>
using namespace std;
typedef struct DLNode {
	int data;
	DLNode* pre;
	DLNode* next;
}LNode, * DLinkList;

//初始化
bool InitDLinkList(DLinkList& l) {
	l = new LNode();
	if (l == nullptr) return false;
	l->pre = nullptr;
	l->next = nullptr;
	return true;
}

//创建双链表
bool DLinkList_Create(DLinkList& l) {
	int x;
	DLNode* s;
	cin >> x;
	while (x != 9999) {
		s = new DLNode();
		s->data = x;
		s->next = l->next;
		if (l->next != nullptr) {
			l->next->pre = s;
		}
		s->pre = l;
		l->next = s;
		cin >> x;
	}
	return true;
}

//插入操作(在p结点之后插入s结点)
bool DLinkList_Insert(LNode* p, LNode* s) {
	if (p == nullptr || s == nullptr) return false;
	s->next = p->next;
	if (p->next != nullptr) {
		p->next->pre = s;
	}
	s->pre = p;
	p->next = s;
	return true;
}

//删除操作(删除p结点的后继结点)
bool DLinkList_Delete(LNode* p) {
	if (p == nullptr) return false;
	LNode* s = p->next;
	if (s == nullptr) return false;
	p->next = s->next;
	s->next->pre = p;
	delete s;
	return true;
}

// 打印双链表
void DLinkList_Print(DLinkList l) {
	DLNode* pri = l->next;
	while (pri != nullptr) {
		cout << pri->data << endl;
		pri = pri->next;
	}
}

int main() {
	DLinkList l;
	InitDLinkList(l);
	DLinkList_Create(l);
	DLinkList_Print(l);
	cout << "----" << endl;
	DLNode* temp = new DLNode();
	temp->data = 10;
	DLinkList_Insert(l->next, temp);
	DLinkList_Print(l);
	cout << "----" << endl;

	/*DLinkList_Delete(l->next);
	DLinkList_Print(l);*/
	return 0;
}
循环单链表
#include <iostream>
using namespace std;
typedef struct CLNode {
	int data;
	CLNode* next;
}CLNode, * CLinkList;

//初始化
bool Init_CLinkList(CLinkList& l) {
	l = new CLNode();
	if (l == nullptr) return false;
	l->next = l;
	return true;
}

//头插法建立循环单链表(有头结点)
CLinkList List_HeadInsert(CLinkList& l) {
	int x;
	CLNode* s;
	l = new CLNode();
	//l = (LinkList)malloc(sizeof(LNode));
	l->next = NULL;
	cin >> x;
	if (x != 9999) {
		s = new CLNode();
		s->data = x;
		s->next = l->next;
		l->next = s;
		s->next = l;
	}
	cin >> x;
	while (x != 9999) {
		s = new CLNode();
		s->data = x;
		s->next = l->next;
		l->next = s;
		cin >> x;
	}
	return l;
}

//尾插法建立循环单链表(有头结点)
CLinkList List_TailInsert(CLinkList& l) {
	int x;
	l = new CLNode();
	CLNode* s;
	CLNode* r = l;
	cin >> x;
	while (x != 9999) {
		s = new CLNode();
		s->data = x;
		r->next = s;
		r = s;
		r->next = l;
		cin >> x;
	}
	r->next = NULL;
	return l;
}

//按序号查找结点(有头结点)
CLNode* Get_Elem(CLinkList l, int i) {
	int j = 1;
	CLNode* temp = l->next;  //temp指向第一个结点
	if (i == 0) return l;
	if (i < 0) return nullptr;
	while (j < i && temp != l && temp != nullptr) {
		temp = temp->next;
		j++;
	}
	return temp;  //如果i大于单链表长度，返回nullptr
}
//按结点值查找结点(有头结点)
CLNode* Locate_Elem(CLinkList l, int e) {
	CLNode* temp = l->next;
	while (temp->data != e && temp != l&&temp!=nullptr) {
		temp = temp->next;
	}
	return temp;
}
//插入结点操作(有头结点)
bool List_Insert(CLinkList& l, int i, int e) {
	if (i < 1) return false;
	CLNode* re = Get_Elem(l, i - 1);
	CLNode* s = new CLNode();
	s->data = e;
	s->next = re->next;
	re->next = s;
	return true;
}

//删除结点操作(有头结点)
bool List_Delete(CLinkList& l, int i) {
	if (i < 1) return false;
	CLNode* re = Get_Elem(l, i - 1);
	CLNode* node_i = re->next;
	re->next = node_i->next;
	delete node_i;
	return true;
}

//求循环单链表表长(有头结点)
int List_length(CLinkList l) {
	int len = 0;
	CLNode* temp = l->next;
	while (temp != l&&temp!=nullptr) {
		temp = temp->next;
		len++;
	}
	return len;
}

//打印循环单链表
void print(CLinkList l) {
	CLNode* temp = l->next;
	while (temp != nullptr) {
		cout << temp->data << endl;
		temp = temp->next;
	}
}

//判断链表是否为空
bool Empty(CLinkList l) {
	if(l->next == l){
		return true;
	}else{
		return false;
	}
}

int main() {
	CLinkList l;
	Init_CLinkList(l);
	List_TailInsert(l);

	cout << Get_Elem(l, 1)->data << endl;
	cout << "---" << endl;
	cout << Locate_Elem(l, 1)->data << endl;
	cout << "---" << endl;
	cout << List_length(l) << endl;
	cout << "---" << endl;
	List_Insert(l, 2, 10);
	cout << "---" << endl;
	List_Delete(l, 1);
	cout << "--" << endl;
	cout << List_length(l) << endl;
	cout << "---" << endl;
	print(l);
	return 0;
}
循环双链表
#include <iostream>
using namespace std;
typedef struct CDLNode {
	int data;
	CDLNode* pre;
	CDLNode* next;
}CDLNode, * CDLinkList;

//初始化
bool InitDLinkList(CDLinkList& l) {
	l = new CDLNode();
	if (l == nullptr) return false;
	l->pre = l;
	l->next = l;
	return true;
}

//创建循环双链表
bool DLinkList_Create(CDLinkList& l) {
	int x;
	CDLNode* s;
	cin >> x;
	while (x != 9999) {
		s = new CDLNode();
		s->data = x;
		s->next = l->next;
		l->next->pre = s;
		s->pre = l;
		l->next = s;
		cin >> x;
	}
	return true;
}

//插入操作(在p结点之后插入s结点)
bool DLinkList_Insert(CDLNode* p, CDLNode* s) {
	if (p == nullptr || s == nullptr) return false;
	s->next = p->next;
	p->next->pre = s;
	s->pre = p;
	p->next = s;
	return true;
}

//删除操作(删除p结点的后继结点)
bool DLinkList_Delete(CDLinkList l, CDLNode* p) {
	if (p == nullptr) return false;
	CDLNode* s = p->next;
	if (s == nullptr||s == l) return false;
	p->next = s->next;
	s->next->pre = p;
	delete s;
	return true;
}

// 打印循环双链表
void DLinkList_Print(CDLinkList l) {
	CDLNode* pri = l->next;
	while (pri != l) {
		cout << pri->data << endl;
		pri = pri->next;
	}
}
//判断循环双链表是否为空
bool Empty(CDLinkList l) {
	if(l->next == l&&l->pre == l) {
		return true;
	}else {
		return false;
	}
}

int main() {
	CDLinkList l;
	InitDLinkList(l);
	DLinkList_Create(l);
	DLinkList_Print(l);
	cout << "----" << endl;
	CDLNode* temp = new CDLNode();
	temp->data = 10;
	DLinkList_Insert(l->next, temp);
	DLinkList_Print(l);
	cout << "----" << endl;
	DLinkList_Delete(l,l->next);
	DLinkList_Print(l);
	return 0;
}
静态链表省略
l0vecamille
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
数据结构考研线性表
06-04
这是数据结构中C语言版部分线性表的学习记录，有关动态在我的博客里有对应。方便大家参考。
王道计算机考研数据结构线性表代码
10-03
王道计算机考研数据结构线性表代码 顺序表 单链表 双链表 循环链表 静态链表 带头节点和不带头节点链表的初始化 链表的节点增加、删除节点、销毁链表、双链表正向打印逆向打印！ 静态链表的初始化以及插入操作
考研数据结构-线性表
sjxgghg的博客
04-18 334
线性表的基本概念与实现 1.线性表的定义 线性表是具有相同特征数据元素的一个有限序列。 元素个数叫做线性表的长度，n(n>=0)表示,n=0(空表) 2.线性表的逻辑特性 只有一个表头元素，只有一个表尾元素。表头无前驱，表尾无后继，除表头和表尾外，其他元素只有一个直接前驱，也只有一个直接后继。 3.线性表的存储结构 顺序存储结构（顺序表）和链式存储结构（链表）两种。 顺序表 ​ 连续存储、顺...
考研数据结构——线性表
blljym的博客
05-01 267
线性表一条考研狗的日常坚持顺序表静态实现动态分配顺序表的特点 一条考研狗的日常坚持 从今天起，我就要坚持每天学几课数据结构，争取将每天的代码完全掌握，手敲才是王道，看懂不是真正的懂，相信自己，我可以的！加油！ 这里并不是将每一个知识都会写在上面，我会贴出我每天的代码，我不会将源码贴出来让你们复制哟，因为数据结构学习的最好的方法就是自己敲！我还会写一些重要的点，有兴趣的可以一起哦，参照的教程是《2...
408考研-数据结构-线性表
quan_yyds的博客
03-07 908
关于线性表数组实现部分的知识和代码笔记
考研数据结构--线性表
Maverick_曲流觞的博客
04-15 613
顺序表的定义,初始化,插入,删除,查找,输出,判空,销毁 单链表的定义,初始化,头插法,尾插法,按序号查找,按值查找,插入,删除,逆置,输出,判空,销毁 双链表的定义,初始化,头插法,尾插法,按序号查找,插入,删除,判空,打印 循环单链表,循环双链表,稀疏多项式
408考研-数据结构-线性表循环链表
quan_yyds的博客
03-10 358
主要记录了部分循环链表相关的代码
2024 王道考研-数据结构（线性表_1）
Xiao_Ya__的博客
10-18 940
2024 王道考研-数据结构 第二章 线性表算法题
计算机考研数据结构----线性表
weixin_43970560的博客
07-07 843
第二章 线性表 一、线性表的定义 线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，其一般表示为L=(a1,a2,a3,…,ai,ai+1,…,an)。 线性表的特点： 1.表中元素的个数有限。 2.表中元素具有逻辑上的顺序性，表中元素有其先后次序。 3.表中元素都是数据元素，每个元素都是单个元素。 4.表中元素的数据类型都相同，每个元素占用相同大小的存储空间。 ai是线性表中的第i个元素在线性表中的位序。 a1是唯一的第一个数据
考研数据结构复习---线性表
qq_43499647的博客
05-24 2860
考纲内容 1.线性表的定义和基本操作 2.线性表的实现 顺序存储;链式存储;线性表的应用 本章知识框架 复习提示 线性表是考研命题的重点.这类算法题实现起来比较容易,代码量少,但是要求具有最优的性能(时间,空间复杂度),才能获得好的分数. 线性表目录1.线性表的定义和基本操作1.1线性表的定义1.2线性表的基本操作2.线性表的顺序表示2.1顺序表的定义2.2顺序表上基本操作的实现3.线性表的链式表示3.1单链表的定义3.2单链表上基本操作的实现3.3双链表3.4循环链表3.5静态链表3.6顺序表.
考研笔记-数据结构-线性表
m0_57005796的博客
03-05 297
线性表的定义 是具有相同特性元素数据元素的一个有限序列。序列中元素的个数叫做线性表的长度。用n表示，n>=0。 线性表的存储结构 顺序表，随机访问特性，占用连续的存储空间。 链表，不支持随机访问，动态随机分配存储空间。 链表的分类 注意事项 单链表删除结点，必须要知道这个结点的前驱结点才可删除。 单链表插入结点，只需要知道此结点的地址即可。 元素逆置，可以用单链表的头插法。也可以用递归函数逆置。 寻找一个数组中出现次数最多的数，循环遍历数组，将遇到的第一个元素存入c，记NUM为1。继续向后遍
计算机考研-数据结构知识点汇总.pdf
08-29
计算机考研数据结构知识点汇总 本资源摘要信息涵盖了计算机考研中的数据结构知识点，包括数据结构的基本概念、逻辑结构、存储结构、算法设计、线性表、链表、队列、栈等知识点。 一、数据结构基本概念 * 数据结构...
数据结构考研资料--线性表及答案
01-05
2008年5月8日 ... 写出将la 和lb两链表归并成一个结点按元素值非递减有序排列的单链表（其头指针为lc），并计算算法的 ... 【北京工业大学1997 一、1 (8分)】 （2）设有两个链表，ha为单向链表，hb为单向循环...
考研复习知识笔记-数据结构
04-16
数据结构笔记-考研复习 数据结构是计算机科学中的一门重要学科，研究如何组织、存储和使用数据。下面是考研复习笔记中的一些重要知识点： 1. 数据结构定义：数据结构是指数据元素之间的逻辑关系、数据的运算和存储...
数据结构--二叉树遍历
最新发布
binhyun的博客
07-15 438
（1）前序遍历 （2）定义结构体 （3）前序遍历实现 （4）中序遍历实现 （5）二叉树的节点个数 （6）二叉树树叶节点个数 （7）二叉树的高度 （8）二叉树节点的开辟 （9）建立一个测试二叉树 （10）测试二叉树相关函数的功能 （11）第k层的数据个数 （12）二叉树里面查找节点
数据结构—链式二叉树-C语言
h_number_1的博客
07-11 833
上述内容，即是我个人对数据结构-链式二叉树-搜索二叉树-C语言的个人见解以及自我实现。若有大佬发现哪里有问题可以私信或评论指教一下我这个小萌新。
【数据结构】二叉树-1
m0_46676283的博客
07-15 550
现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 ，则它就是满二叉树。双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；
数据结构(4.4)——求next数组
m0_65240792的博客
07-14 299
next[1]都无脑写0next[2]都无脑写1其他next:在不匹配的位置前边，划一条分界线，模式串一步一步往后退，直到分界线之前"能对上"，或模式串能完全跨过分界线为止，此时j指向哪儿，next数组值就是多少ababaa的next数组//求next[1]??????->??????/i=1->i=2ababaa-> ababaa //j=0,第一个字符匹配失败，只能匹配下一个子串，++i，++jnext[1]=0;//求next[2]a?????->a??????//i=2。
考研数据结构 线性表
09-17
线性表有多种存储结构，包括顺序表、单链表、双链表、循环链表和静态链表等。顺序表是将线性表中的元素依次存储在一块连续的存储空间中。单链表是将线性表中的元素存储在多个结点中，并通过指针链接起来。双链表在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值