顺序表的实现-c语言

最新推荐文章于 2024-07-20 18:37:44 发布
最新推荐文章于 2024-07-20 18:37:44 发布
阅读量233 收藏
点赞数 5
文章标签： c语言 算法 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyl0327/article/details/134356749
版权

顺序表是什么？

顺序表（Sequential List）是一种线性数据结构，它是一种用于存储和管理一组元素的数据结构，其中元素按照一定的顺序排列在内存中的连续存储区域中。顺序表通常用于静态分配或动态分配内存来存储元素。

以下是顺序表的一些关键特点和简单介绍：

  1. 连续存储：顺序表中的元素在内存中是连续存储的，这意味着每个元素都紧邻着下一个元素存储，因此可以通过下标或偏移来快速访问元素。

  2. 固定或动态大小：顺序表可以是固定大小的（静态顺序表）或动态大小的（动态顺序表）。静态顺序表在创建时分配固定大小的内存，不能动态增加或减少元素的数量。而动态顺序表可以根据需要自动扩展或收缩内存空间以容纳更多或更少的元素。

  3. 随机访问：由于元素在连续存储区域中，顺序表支持随机访问，可以通过索引或下标在常量时间内访问任何位置的元素。

  4. 插入和删除的效率：在静态顺序表中，插入和删除元素可能需要移动其他元素以维护顺序，因此效率较低。而在动态顺序表中，插入和删除的效率通常较高，但仍可能需要进行内存分配或释放操作。

  5. 适用场景：顺序表适用于需要频繁随机访问元素，但不需要频繁插入和删除元素的情况。它们通常用于实现数组、列表、栈和队列等抽象数据类型。

总之，顺序表是一种常见的数据结构，具有快速的随机访问特性，但在插入和删除方面的效率可能有所不足，因此在选择数据结构时需要根据具体应用场景来考虑是否使用顺序表。

顺序表的实现

下面我们将一步一步的完成顺序表的实现：

头文件的规划

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SLDataType;

typedef struct Seqlist {
	int* a;        // a是一个指针，类似数组的首元素的地址
	int size;	//有效数据
	int capacity;	//空间容量
}SL;

void SLInit(SL* psl);
void SLDestroy(SL* psl);

void SLPrint(SL* psl);

void SLCheckCapacity(SL* psl);

//头尾插入删除
void SLPushBack(SL* psl, SLDataType x);
void SLPushFront(SL* psl, SLDataType x);
void SLPopBack(SL* psl);
void SLPopfront(SL* psl);

//任意下标位置插入和删除
void SLInsert(SL* psl, int pos, SLDataType x);
void SLErase(SL* psl, int pos);

简单介绍一下这个头文件内包含了什么 ：

这个结构体名为Seqlist，它由三个成员组成，每个成员的作用如下：

  1. int* a：这是一个指向整数类型的指针，用于存储顺序表中的元素。通常，它指向一个动态分配的整数数组，这个数组用来存储顺序表的元素。通过指针，可以访问和操作顺序表中的元素。

  2. int size：这是一个整数，用于记录当前顺序表中有效数据的数量。也就是说，它表示顺序表中当前存储的元素个数。通过size可以快速获取顺序表的大小。

  3. int capacity：这是一个整数，用于记录顺序表的容量，即可以容纳的最大元素数量。它表示了顺序表内部分配的存储空间的大小。当顺序表的元素数量接近容量时，通常需要进行扩容操作，以容纳更多的元素。

这个结构体的成员组合在一起，用于表示一个顺序表数据结构，其中a指向一个整数数组，size记录有效数据的数量，capacity表示容量。这个结构体的定义提供了一个框架，使得可以在其中存储和管理整数类型的元素，同时跟踪顺序表的大小和容量信息。

初始化顺序表

void SLInit(SL* psl) {

	assert(psl->a != NULL);

	psl->a = NULL;
	psl->size = 0;
	psl->capacity = 0;
}

上面的函数SLInit是用于初始化一个顺序表（结构体 SL）的函数。它接受一个指向顺序表的指针 psl 作为参数，并将该顺序表的成员变量初始化为特定的初始状态。

具体而言，该函数的主要操作如下：

  1. assert(psl->a != NULL);：这是一个断言语句，用于检查传入的顺序表 psl 的 a 成员是否为 NULL。如果 a 不是 NULL，则断言成功，程序继续执行。如果 a 是 NULL，则断言失败，程序会引发错误并停止执行。这个断言的目的是确保在初始化之前，顺序表的 a 成员不为空，以避免潜在的内存错误。

  2. psl->a = NULL;：接下来，函数将顺序表的 a 成员设置为 NULL，这表示将其指向空指针，即没有分配内存的状态。这是为了确保在初始化之后，a 不再指向任何之前分配的内存区域，以避免内存泄漏。

  3. psl->size = 0;：将顺序表的 size 成员初始化为0，表示当前顺序表中没有有效的数据元素。

  4. psl->capacity = 0;：将顺序表的 capacity 成员初始化为0，表示当前顺序表的容量为0，即没有分配任何内存用于存储数据。

总之，SLInit 函数的作用是将传入的顺序表 psl 初始化为一个空表，即没有分配内存用于存储数据，size 和 capacity 都被设置为0。这个初始化操作可以在开始使用顺序表之前调用，以确保顺序表处于合适的初始状态。在初始化之前，还使用断言检查 a 成员不为空，以提前发现潜在的错误。这是保证程序的健壮性和安全性的一种常见做法。

顺序表的销毁

void SLDestroy(SL* psl) {
	assert(psl);
	if (psl->a != NULL) {
		free(psl->a);
		psl->a = NULL;
		psl->size = 0;
		psl->capacity = 0;
	}
}

SLDestroy 函数用于销毁（释放）一个顺序表，释放与顺序表相关联的动态分配的内存，并将顺序表的成员变量重置为初始状态，以便下次使用。以下是该函数的主要操作：

  1. assert(psl);：这个断言用于确保传入的指针 psl 不为空。它确保在进行销毁操作之前，psl 必须是有效的，以防止对空指针的非法操作。

  2. if (psl->a != NULL)：这个条件判断用于检查顺序表的 a 成员是否为 NULL，如果不为 NULL，说明顺序表内部有动态分配的内存。

  3. free(psl->a);：如果 a 不为 NULL，则调用 free 函数释放 a 指向的动态分配的内存。这一步非常重要，因为它确保在销毁顺序表时释放了所有分配的内存，避免了内存泄漏。

  4. psl->a = NULL;：将顺序表的 a 成员设置为 NULL，以确保不再指向之前释放的内存区域。

  5. psl->size = 0; 和 psl->capacity = 0;：将顺序表的 size 和 capacity 成员都设置为0，表示顺序表已经为空，并且容量为0。

总之，SLDestroy 函数的主要作用是释放顺序表 psl 内部动态分配的内存，确保在程序结束后不会发生内存泄漏。同时，它将顺序表的成员变量重置为初始状态，以便下次使用。这个函数的正确实现非常重要，因为内存泄漏可能会导致程序的性能问题和不稳定性。

顺序表的打印

void SLPrint(SL* psl) {
	assert(psl);
	for (int i = 0; i < psl->size; i++) {
		printf("%d ", psl->a[i]);

	}
	printf("\n");
}

SLPrint 函数是用于打印顺序表中的元素的功能函数。它接受一个指向顺序表的指针 psl 作为参数，并通过一个循环遍历顺序表的元素，将它们按顺序打印到控制台上，每个元素之间用空格分隔，最后添加一个换行符。这个函数有助于在调试和测试时查看顺序表中的数据，以验证程序的正确性，但请确保传入的顺序表指针不为空以避免异常情况

顺序表的空间扩容

void SLCheckCapacity(SL* psl) {
	assert(psl);

	if (psl->size == psl->capacity) {
		int newCapacity = psl->capacity == 0 ? 4 : psl->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(psl->a, sizeof(SLDataType) * newCapacity);//如果空间是空，realloc也可以开一个新的空间
		if (tmp == NULL) {
			perror("realloc fail");
			return;
		}
		psl->a = tmp;
		psl->capacity = newCapacity;
	}
}

上面的函数 SLCheckCapacity 用于检查顺序表的容量是否足够，并在需要时进行扩容。以下是对该函数的详细介绍：

  1. assert(psl);：这是一个断言语句，用于确保传入的指针 psl 不为空（不为 NULL）。如果 psl 为空，断言会失败，导致程序中止。这个断言旨在确保在执行扩容操作之前，传入的顺序表指针有效，以防止出现潜在的问题。

  2. if (psl->size == psl->capacity)：这是一个条件判断，用于检查顺序表的 size（当前有效数据的数量）是否等于 capacity（顺序表的容量，即可以容纳的最大元素数量）。如果相等，说明当前容量不足以容纳更多的元素，需要进行扩容。

  3. int newCapacity = psl->capacity == 0 ? 4 : psl->capacity * 2;：在需要扩容时，计算新的容量 newCapacity。如果当前容量是0（表示顺序表为空），则将新容量设置为4；否则，将新容量设置为当前容量的两倍，以扩大顺序表的容量。

  4. SLDataType* tmp = (SLDataType*)realloc(psl->a, sizeof(SLDataType) * newCapacity);：使用 realloc 函数尝试重新分配内存，将顺序表的 a 成员扩展到新的容量 newCapacity。realloc 函数首先尝试在原有内存块上扩展空间，如果失败，则会在堆上分配新的内存块，并将数据从旧内存块复制到新内存块。tmp 是一个临时指针，用于指向重新分配后的内存块。同时相较于mealloc开辟新的空间相比，realloc可以保证新开辟的内存不存在异地内存的可能性，这也节省了一些运行时间，其中必须sizeof(SLDataType)*newCapacity如果不乘sizeof(SLDataType),不能保证增加的每个空间开辟了需要的4个字节的空间。

  5. if (tmp == NULL)：在尝试扩容后，检查 tmp 是否为 NULL。如果 tmp 为 NULL，说明内存分配失败，通常是由于内存不足导致的。在这种情况下，程序会输出错误消息并返回，扩容操作失败。

  6. psl->a = tmp;：如果扩容成功，将 psl 的 a 成员指向新分配的内存块，即 tmp 所指向的地址。

  7. psl->capacity = newCapacity;：更新顺序表的 capacity 成员，将其设置为新的容量 newCapacity。

总之，SLCheckCapacity 函数的作用是在需要时扩展顺序表的容量，以容纳更多的元素。它通过检查当前有效数据的数量和容量的关系来判断是否需要扩容，然后使用 realloc 函数进行内存的重新分配。这个函数确保顺序表能够动态地扩展其容量，以适应不断增长的数据集合。

 

顺序表的从头插入和从尾插入

void SLPushBack(SL* psl, SLDataType x) {
	assert(psl);

		
	SLCheckCapacity(psl);
	psl->a[psl->size] = x;//将a数组内下标为size的内容变成x，因为size代表的是最后的数据下标
	psl->size++;

}
void SLPushFront(SL* psl, SLDataType x) {
	assert(psl);

	SLCheckCapacity(psl);
	int end = psl->size - 1;

	//挪动数据
	while (end >= 0) {
		psl->a[end + 1] = psl->a[end];//将后面的数据向前移动一个
		--end;
	}
	psl->a[0] = x;
	psl->size++;
}

上面的两个函数 SLPushBack 和 SLPushFront 用于在顺序表的尾部和头部插入元素，它们有以下不同的功能：

  1. SLPushBack 函数：

    • SLPushBack 的作用是将一个元素 x 插入到顺序表的尾部。
    • 首先，函数使用 assert 断言来确保传入的顺序表指针 psl 不为空。
    • 然后，调用 SLCheckCapacity(psl) 来检查顺序表的容量是否足够，如果容量不足，会自动扩容。
    • 接下来，将元素 x 插入到顺序表的尾部，即在数组 a 的索引为 psl->size 的位置处赋值为 x，并将 size 增加1，表示有效数据数量增加了一个元素。

  2. SLPushFront 函数：

    • SLPushFront 的作用是将一个元素 x 插入到顺序表的头部。
    • 同样，函数开始使用 assert 断言来确保传入的顺序表指针 psl 不为空。
    • 然后，调用 SLCheckCapacity(psl) 来检查顺序表的容量是否足够，如果容量不足，会自动扩容。
    • 接下来，函数使用循环将顺序表中的元素向后挪动一个位置，以为新元素 x 腾出空间。
    • 最后，将元素 x 插入到顺序表的头部，即在数组 a 的索引为0的位置处赋值为 x，并将 size 增加1，表示有效数据数量增加了一个元素。

 

顺序表的从头删除和从尾删除

void SLPopBack(SL* psl) {
	assert(psl);

	//温柔的检查
	//if (psl->size == 0) {
	//	return;
	//}

	//暴力的检查
	assert(psl->size > 0);
	//psl->a[psl->size - 1] = -1;//但是-1已经把这个数给写死了，不能改变数据
	psl->size--; //光光改变size时，当减到0的时候，size会减到负数，后续加数据会从-1开始，导致数据错误
//所以要在函数中保证psl中size不能是负数
}
void SLPopfront(SL* psl) {
	assert(psl);

	assert(psl->size > 0);

	int begin = 1;
	while (begin < psl->size) {
		psl->a[begin - 1] = psl->a[begin];
		++begin;
	}
	psl->size--;

}

上面的两个函数 SLPopBack 和 SLPopfront 分别用于从顺序表的尾部和头部删除元素。它们的作用如下：

  1. SLPopBack 函数：

    • SLPopBack 的作用是从顺序表的尾部删除一个元素。
    • 首先，函数使用 assert 断言来确保传入的顺序表指针 psl 不为空。
    • 接下来，函数使用 assert(psl->size > 0) 断言来检查顺序表中是否有有效的数据。如果顺序表的 size 为0，即没有有效数据，函数将无法继续执行删除操作，这是一种温柔的检查。
    • 然后，函数将顺序表的 size 成员减1，表示有效数据数量减少一个元素，相当于从尾部删除了一个元素。这是通过减小 size 来实现的，不会直接操作数组元素的值。

  2. SLPopfront 函数：

    • SLPopfront 的作用是从顺序表的头部删除一个元素。
    • 同样，函数开始使用 assert 断言来确保传入的顺序表指针 psl 不为空。
    • 然后，函数使用 assert(psl->size > 0) 断言来检查顺序表中是否有有效的数据，如果 size 为0，函数将无法继续执行删除操作。
    • 接下来，函数使用一个循环将顺序表中的元素向前挪动一个位置，以覆盖被删除的元素。这个过程将元素逐个向前移动，直到删除的元素从顺序表中被完全覆盖。
    • 最后，将顺序表的 size 成员减1，表示有效数据数量减少一个元素，相当于从头部删除了一个元素。

顺序表的任意位置的删除和插入

void SLInsert(SL* psl, int pos, SLDataType x) {
	assert(psl);
	assert(pos >= 0 && pos <= psl->size);
	SLCheckCapacity(psl);
	int end = psl->size - 1;
	while (end >= pos) {//保证了在pos之后的内容都向后移动一格
		psl->a[end + 1] = psl->a[end];
		--end;
	}
	psl->a[pos] = x;//再将元素插入顺序表
	psl->size++;


}
void SLErase(SL* psl, int pos) {
	assert(psl);
	assert(pos >= 0 && pos < psl->size);//size的位置指向空，所以删除就没有意义
	//挪动覆盖
	int begin = pos + 1;
	while (begin < psl->size) {
		psl->a[begin - 1] = psl->a[begin];//可以直接覆盖，不需要删除
		++begin;

	}
	psl->size--;


}

上面的两个函数 SLInsert 和 SLErase 分别用于在顺序表中插入元素和删除元素，下面是它们的实现：

  1. SLInsert 函数：

    • SLInsert 的作用是在顺序表的指定位置 pos 处插入一个元素 x。
    • 首先，函数使用两个 assert 断言来确保传入的顺序表指针 psl 不为空，并且 pos 的值在有效范围内，即大于等于0且小于等于当前有效数据数量 psl->size。
    • 接下来，函数调用 SLCheckCapacity(psl) 来检查容量是否足够，如果需要，会自动进行扩容。
    • 然后，函数使用一个循环将顺序表中从位置 pos 开始的元素都向后挪动一个位置，以为新元素 x 腾出位置。
    • 最后，将元素 x 插入到位置 pos 处，更新 size 成员，表示有效数据数量增加了一个元素。

  2. SLErase 函数：

    • SLErase 的作用是从顺序表中删除指定位置 pos 处的元素。
    • 同样，函数使用两个 assert 断言来确保传入的顺序表指针 psl 不为空，并且 pos 的值在有效范围内，即大于等于0且小于当前有效数据数量 psl->size。
    • 接下来，函数使用一个循环将顺序表中从位置 pos+1 开始的元素都向前覆盖一个位置，以删除指定位置的元素。
    • 最后，将 size 成员减1，表示有效数据数量减少了一个元素。
yyl0327
关注
  • 5
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
【小白打基础系列】线性表的应用之单词检查
elegant_cheater的博客
06-18 1174
2020数据结构课程设计之单词检查： 单词检查(Ⅰ)- 顺序表实现 许多应用程序，如字处理软件，邮件客户端等，都包含了单词检查特性。单词检查是根据字典，找出输入文本中拼错的单词，我们认为凡是不出现在字典中的单词都是错误单词。不仅如此，一些检查程序还能给出类似拼错单词的修改建议单词。 例如字典由下面几个单词组成： bake cake main rain vase 如果输入文件中有词vake ，检查程序就能发现其是一个错误的单词，并且给出 bake, cake或vase做为修改建议单词。 修改建议单词可以采用
顺序表----c语言实现
weixin_65846395的博客
03-13 83
线性表的顺序存储又称顺序表。它是用一组地址连续的存储单元依次存储线性表中的数据元素，从而使逻辑是相邻的二个元素在物理位置上也相邻。第1个元素存储在线性表的起始位置，第i个元素的存储位置后面紧接着存储的是第i+1个元素，称i为元素Ai在线性表的位序。因此，顺序表的特点是表中元素的逻辑顺序与物理顺序相同。//用来指向开辟的空间int size;//当前存储数据的个数//容量的大小}SL;
单词检查(Ⅰ)- 顺序表实现
qq_46193581的博客
06-18 5107
题目描述 许多应用程序，如字处理软件，邮件客户端等，都包含了单词检查特性。单词检查是根据字典，找出输入文本中拼错的单词，我们认为凡是不出现在字典中的单词都是错误单词。不仅如此，一些检查程序还能给出类似拼错单词的修改建议单词。 例如字典由下面几个单词组成： bake cake main rain vase 如果输入文件中有词vake ，检查程序就能发现其是一个错误的单词，并且给出 bake, cake或vase做为修改建议单词。 修改建议单词可以采用如下生成技术： (1)在每一个可能位置插入‘a-‘z’中的一
[1] 顺序表实现
benxiangsj的博客
04-09 503
自己实现了顺序表
用c语言实现顺序表
gunqu_d的博客
09-24 1004
用c语言实现顺序表 Seqlist.h #pragma once typedef int DataType; #define N 100 typedef struct Seqlist { DataType array[N]; size_t size; }Seqlist; void InitSeqlist(Seqlist* s); //初始化 void PrintSeqlist(Seqli
数据结构-顺序表-C语言实现顺序表相关功能-数据结构学习
05-22
C语言实现的数据结构中的顺序表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习 对顺序表边界操作的判定 实现了以下功能： 创建顺序表 向顺序表中插入元素(尾插法，...
C语言实现动态顺序表的实现代码
12-31
C语言实现动态顺序表的实现代码 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据...来看看动态的顺序表实现： 1.seqlist.h #define _CRT_SECURE_NO_WARNINGS 1 #ifnd
C语言顺序表的实现代码
08-29
C语言顺序表的实现代码 C语言顺序表是一种基本的数据结构，广泛应用于计算机科学和软件开发中。本文主要为大家详细介绍了C语言实现顺序表的实现代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。 顺序表...
C语言顺序表实现代码排错
09-04
C语言顺序表实现代码排错 在这篇文章中，我们将详细介绍C语言顺序表实现的方法，并提供了一个完整的示例代码。顺序表是一种常用的数据结构，它可以存储大量的数据，并提供了插入、删除、查找等操作。 首先，我们...
【数据结构】---顺序表的实现
喜欢编写一些小程序的科班菜鸟，但是由于准备考研，博客不能及时更新了，不好意思！
02-13 762
关于顺序表的介绍
顺序表的实现
u014723123的专栏
04-15 437
使用c++实现一下常用的数据结构，参考书为《数据结构、算法与应用－c++语言描述》。 此次代码为顺序表，为了保证通用性采用模板机制，算法本身没有什么难度，毕竟是基础算法，但是长时间不用c++，一些高级特性和陷阱着实让人难受。 此次代码共分三个文件： 1、Sq_list.h ：实现顺序表的结构和基本操作。 2、excp.h ：实现异常类，关于命名空间的问题，直接将异常类加入到std空间内。
【顺序表】
student_wdqing的博客
12-14 125
数据结构_顺序表
2.1顺序表的实现
qq_73917326的博客
03-28 62
自己写的GetElement函数及测试调试了很久才成功运行，但老师代码部分誊抄错误的。3.收获：老师写注释的方式非常值得我们学习，我抄完代码后发现编译有很多错误，我。地方能够快速地纠正，我发现多得益于测试代码的存在。对函数的执行进行分步，虽然。1.我仿照闵帆老师的写法，编写了GetElement函数及其测试函数。2.对比老师的代码，发现有很难像老师一样写出简洁而且模块化的代码。在编写花费了更多的时间，却增强代码的可调试性。e.g:代码里面好像有四处单词拼写错误。
数据结构课程设计-单词检查
代码行
07-02 6967
问题 I: 单词检查(Ⅰ)- 顺序表实现 时间限制: 1 Sec 内存限制: 128 MB 提交: 2227 解决: 736 [提交][状态][讨论版] 题目描述 许多应用程序，如字处理软件，邮件客户端等，都包含了单词检查特性。单词检查是根据字典，找出输入文本中拼错的单词，我们认为凡是不出现在字典中的单词都是错误单词。不仅如此，一些检查程序还能给出类似拼错单词的修改建议单词。 例如字典由下面几...
单词检查(Ⅱ)- 二叉排序树实现
qq_46193581的博客
06-18 5925
题目描述 许多应用程序，如字处理软件，邮件客户端等，都包含了单词检查特性。单词检查是根据字典，找出输入文本中拼错的单词，我们认为凡是不出现在字典中的单词都是错误单词。不仅如此，一些检查程序还能给出类似拼错单词的修改建议单词。 例如字典由下面几个单词组成： bake cake main rain vase 如果输入文件中有词vake ，检查程序就能发现其是一个错误的单词，并且给出 bake, cake或vase做为修改建议单词。 修改建议单词可以采用如下生成技术： (1)在每一个可能位置插入‘a-‘z’中的一
结构体[C语言]
最新发布
Q741_147的博客
07-20 263
在 C 语言中，我们使用struct关键字来定义结构体。// 定义学生结构体int age;// 后续代码...return 0;在这个例子中，我们定义了一个名为Student的结构体，它包含一个字符数组name用于存储姓名，一个整数age用于存储年龄，以及一个浮点数score用于存储成绩。
静态顺序表的实现c语言
03-19
下面是静态顺序表的C语言实现： ```c #define MAX_SIZE 100 // 定义静态顺序表的最大容量 typedef struct { int data[MAX_SIZE]; // 用数组存储数据元素 int length; // 当前顺序表的长度 } SeqList; // 初始化...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值