模拟实现顺序表-动态的存储方式

最新推荐文章于 2024-05-13 19:38:16 发布
原创 最新推荐文章于 2024-05-13 19:38:16 发布 · 1.7k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#结构体 #顺序表动态存储

本文详细介绍了如何使用动态存储方式实现顺序表，并通过冒泡排序、直接插入排序和选择排序三种方法对顺序表进行排序操作。文章还提供了完整的代码实现，包括初始化、插入、删除、查找和排序等功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

         模拟实现顺序表-静态的方式

        

         我们知道静态的存储方式中数组Data的大小是固定的是100，也就是说我们最多只能存储100组信息数据，当要增加信息数据时我们就需要扩大数组Data的大小，是不是很麻烦呢？这就要提出我们今天要实现的版本 -动态的存储方式.
        首先我们先来看顺序表的结构成员，实现代码如下：
         
typedef int DataType;  

typedef struct SeqList  
{  
    DataType *Data;  
    int size;  
	int capacity;   //容量
}SeqList,*pSeqList;
        我们先给出程序的测试代码：
         
#include"SeqList_dyna.h"

void text()
{
	int x=0;  
    int input=1;  
    int pos=0;  
	int ret=0;
    SeqList pSeq;  
    Init_SeqList(&pSeq);  
    while(input)  
    {  
        menu();  
        printf("请选择一个你要进行的操作:");  
        scanf("%d",&input);  
        switch(input)  
        {  
        case 1:  
            printf("请输入一个你要插入的数据:");  
            scanf("%d",&x);  
            Push_Back(&pSeq,x);  
            break;  
        case 2:  
             Pop_Back(&pSeq);  
             break;  
        case 3:  
            printf("请输入一个你要插入的数据:");  
            scanf("%d",&x);  
            Push_front(&pSeq,x);  
            break;  
        case 4:  
            Pop_front(&pSeq);  
            break;  
        case 5:  
            printf("请输入一个你要插入的数据:");  
            scanf("%d",&x);  
            printf("请输入你要插入的位置:");  
            scanf("%d",&pos);  
            Insert_SeqList(&pSeq,pos,x);  
            break;  
        case 6:  
            printf("请输入一个你要删除的数据:");  
            scanf("%d",&x);  
            Remove_SeqList(&pSeq,x);  
            break;  
        case 7:  
            printf("请输入一个你要删除的数据:");  
            scanf("%d",&x);  
            RemoveAll_SeqList(&pSeq,x);  
            break;  
        case 8:  
            Bubble_Sort(&pSeq);  
            break;  
        case 9: 
			Insertion_Sort(&pSeq);
            break;  
        case 10:  
			Select_Sort(&pSeq);
			break;
		case 11:
			Print_SeqList(&pSeq); 
			break;
		case 12:
			printf("请输入一个你要查找的数据:");  
            scanf("%d",&x);  
            ret=Binary_Search(&pSeq,x);  
			if(pSeq.Data[ret] == x)
			{
				printf("查找成功\n");
			}
			else
			{
				printf("查找失败\n");
			}
			break;
        case 0: 
			Free_SeqList(&pSeq);
            break;  
        default:  
            printf("您的输入错误请重新选择\n");  
            break;  
        }  
    }  
}

int main()  
{  
	text();
    system("pause");  
    return 0;  
}
         
        既然要动态增加 存储信息的个数，malloc当然少不了啦！malloc用于给指针Data分配初始空间当顺序表长度增加到和顺序表的容量一致时，此时就需要realloc进行扩容工作了，当添加信息时就需要判断是否需要增加扩容了；分配空间和扩容的代码 实现如下：
        分配空间：
          
void Init_SeqList(pSeqList pSeq)  
{  
    //pSeq->size=0;  
    //memset(pSeq->Data,0,MAX*sizeof(DataType));  
	pSeq->Data=(DataType *)malloc(sizeof(DataType)*MAX_INIT);
	if(NULL == pSeq->Data)
	{
		printf("out of memory\n");
		exit(EXIT_FAILURE);
	}
	pSeq->size=0;
	pSeq->capacity=MAX_INIT;
}
        扩容：
         
void Judge_Full(pSeqList pSeq)    //判断容量是否满了
{
	if(pSeq->capacity == pSeq->size)
	{
		DataType *tmp=(DataType *)realloc(pSeq->Data,(pSeq->capacity+MAX_ADD)*sizeof(DataType));
		if(NULL == pSeq->Data)
		{
			printf("out of memory\n");
			exit(EXIT_FAILURE);
		}
		else
		{
			pSeq->Data=tmp;
			pSeq->capacity+=MAX_ADD;
		}
	}
}
        
        SeqList_dyna.h
         
#define _CRT_SECURE_NO_WARNINGS  
#ifndef __SEQLIST_D_H__    //防止重复引入
#define __SEQLIST_D_H__
#include<stdio.h>  
#include<stdlib.h>  
#include<string.h>  
#include<assert.h>  

#define MAX 100  
#define MAX_INIT 3
#define MAX_ADD 3
typedef int DataType;  

typedef struct SeqList  
{  
    DataType *Data;  
    int size;  
	int capacity;   //容量
}SeqList,*pSeqList;  

void menu();
void Print_SeqList(pSeqList pSeq);         //打印输出  
void Init_SeqList(pSeqList pSeq);          //初始化  
void Judge_Full(pSeqList pSeq);            //判断容量是否满了
void Free_SeqList(pSeqList pSeq);          //释放空间
void Push_Back(pSeqList pSeq,DataType x);  //尾插  
void Pop_Back(pSeqList pSeq);              //尾删  
void Push_front(pSeqList pSeq,DataType x); //头插  
void Pop_front(pSeqList pSeq);             //头删  
void Insert_SeqList(pSeqList pSeq,int pos,DataType x); //在顺序表的指定位置插入指定的元素  
void Remove_SeqList(pSeqList pSeq,DataType x);       //删除特定的元素  
void RemoveAll_SeqList(pSeqList pSeq,DataType x);    //删除全部的特定元素  
void Bubble_Sort(pSeqList pSeq);            //冒泡排序 
void Insertion_Sort(pSeqList pSeq);         //直接插入排序 
void Select_Sort(pSeqList pSeq);            //选择排序
int Find_NUM(pSeqList pSeq ,DataType x);               
int Binary_Search(pSeqList pSeq,DataType x);          


#endif //__SEQLIST_D_H__
         SeqList_dyna.c
          
#include"SeqList_dyna.h"

void menu()  
{  
    printf("***********************************************\n");  
    printf("*****0.exit**1.Push_Back**2.Pop_Back***********\n");  
    printf("*****3.Push_front*********4.Pop_front**********\n");  
    printf("*****5.Insert_SeqList*****6.Remove_SeqList*****\n");  
    printf("*****7.RemoveAll_SeqList**8.Bubble_Sort********\n");  
	printf("*****9.Insertion_Sort*****10.Select_Sort*******\n"); 
    printf("****11.Print_SeqList******12.Binary_Search*****\n");  
    printf("***********************************************\n");  
} 

void  Print_SeqList(pSeqList pSeq)  
{  
    int i=0;  
    assert(pSeq);  
    for(i=0;i<pSeq->size;i++)  
    {  
        printf("%d ",pSeq->Data[i]);  
    }  
    printf("\n");  
}  
  
void Init_SeqList(pSeqList pSeq)  
{  
    //pSeq->size=0;  
    //memset(pSeq->Data,0,MAX*sizeof(DataType));  
	pSeq->Data=(DataType *)malloc(sizeof(DataType)*MAX_INIT);
	if(NULL == pSeq->Data)
	{
		printf("out of memory\n");
		exit(EXIT_FAILURE);
	}
	pSeq->size=0;
	pSeq->capacity=MAX_INIT;
}  

void Judge_Full(pSeqList pSeq)    //判断容量是否满了
{
	if(pSeq->capacity == pSeq->size)
	{
		DataType *tmp=(DataType *)realloc(pSeq->Data,(pSeq->capacity+MAX_ADD)*sizeof(DataType));
		if(NULL == pSeq->Data)
		{
			printf("out of memory\n");
			exit(EXIT_FAILURE);
		}
		else
		{
			pSeq->Data=tmp;
			pSeq->capacity+=MAX_ADD;
		}
	}
}

void Push_Back(pSeqList pSeq,DataType x)    
{  
    assert(pSeq);   
	Judge_Full(pSeq);
    pSeq->Data[pSeq->size]=x;  
    pSeq->size++;  
}  
  
void Pop_Back(pSeqList pSeq)  
{  
    assert(pSeq);  
    if(pSeq->size == 0)  
    {  
        printf("顺序表已空\n");  
        return ;  
    }  
    pSeq->size--;   
}  
  
void Push_front(pSeqList pSeq,DataType x)  //在顺序表的前面添加元素  
{  
    int i=0;  
    assert(pSeq);  
	Judge_Full(pSeq);
    for(i=pSeq->size-1;i>=0;i--)  
    {  
        pSeq->Data[i+1]=pSeq->Data[i];  
    }  
    pSeq->Data[0]=x;  
    pSeq->size++;  
}  
  
void Pop_front(pSeqList pSeq)  
{  
    int i=0;  
    assert(pSeq);  
    for(i=0;i<pSeq->size;i++)  
    {  
        pSeq->Data[i]=pSeq->Data[i+1];  
    }  
    pSeq->size--;  
}  
  
void Insert_SeqList(pSeqList pSeq,int pos,DataType x)  //在指定指定位置插入元素x，pos是下标  
{  
    int i=0;  
    assert(pSeq);  
	Judge_Full(pSeq);
    for(i=pSeq->size-1;i>=pos;i--)  
    {  
        pSeq->Data[i+1]=pSeq->Data[i];  
    }  
    pSeq->Data[pos]=x;  
    pSeq->size++;  
}  
  
void Remove_SeqList(pSeqList pSeq,DataType x)   //删除指定元素  
{  
    int i=0;  
    int ret=0;  
    ret= Find_NUM(pSeq,x);  
    assert(pSeq);  
    if(ret == -1)  
    {  
        printf("顺序表中没有此元素\n");  
        return ;  
    }  
    else  
    {  
        for(i=ret;i<pSeq->size;i++)  
        {  
            pSeq->Data[i]=pSeq->Data[i+1];  
        }  
    }  
    pSeq->size--;  
    printf("删除成功\n");  
}  
  
int Find_NUM(pSeqList pSeq ,DataType x)            //查找函数  
{  
    int i=0;  
    for(i=0;i<pSeq->size;i++)  
    {  
        if(pSeq->Data[i] == x)  
            return i;  
    }  
    return -1;  
}  
  
void RemoveAll_SeqList(pSeqList pSeq,DataType x)  //删除所有指定元素  
{  
    int i=0;  
    int j=0;  
    int ret=0;  
    assert(pSeq);  
    while(ret < pSeq->size)  
    {  
        ret=Find_NUM(pSeq,x);  
        if(ret == -1)  
        {     
            printf("顺序表中没有此元素\n");  
            return ;  
        }  
        else  
        {  
            for(i=ret;i<pSeq->size;i++)  
            {  
                pSeq->Data[i]=pSeq->Data[i+1];  
            }  
        }  
        pSeq->size--;  
        ret++;  
    }  
    printf("删除成功\n");  
}  
  
void Bubble_Sort(pSeqList pSeq)   //冒泡排序  
{  
    int i=0;  
    int j=0; 
	int m=0;
    DataType tmp=0;  
    int flag=0;
	int k=pSeq->size-1;
    assert(pSeq);  
    for(i=0;i<pSeq->size-1;i++)  
    {  
		m=0;
        flag=0;                                 //对冒泡排序的优化  
        for(j=0;j<k;j++)      //每次都从最后一次交换的位置继续执行
        {  
            if(pSeq->Data[j] > pSeq->Data[j+1])  //默认升序排列  
            {  
                tmp=pSeq->Data[j];  
                pSeq->Data[j]=pSeq->Data[j+1];  
                pSeq->Data[j+1]=tmp;  
                flag=1;  
				m=j;       //用来记录最后一次交换的位置
            }  
        }  
        if(flag == 0)  
            break; 
		k=m;      //将k置成最后一次交换的位置
    }  
}  

void Insertion_Sort(pSeqList pSeq)         //直接插入排序 
{
	int i=0;
	int j=0;
	int k=0;
	DataType tmp=0;
	for(i=1;i<pSeq->size;i++)   //选取第一个元素为有序的将其他数字插入它的两边
	{
		tmp=pSeq->Data[i];
		for(j=i-1;j>=0;j--)
		{
			if(pSeq->Data[i] >= pSeq->Data[j])   //升序排列
			{
				break;
			}
		}
		for(k=i-1;k>j;k--)   //移位,空出位置插入tmp,也可以交换
		{
			pSeq->Data[k+1]=pSeq->Data[k];
		}
		pSeq->Data[j+1]=tmp;
	}
}

void Select_Sort(pSeqList pSeq)            //选择排序，升序排列
{
	int i=0;
	int j=0;
	int min=0;
	for(i=0;i<pSeq->size-1;i++)
	{
		min=i;
		for(j=i+1;j<pSeq->size;j++)
		{
			if(pSeq->Data[j] < pSeq->Data[min])   //找到i后面所有数据的最小值
			{
				min=j;
			}
		}
		if(i != min)    //找到的最小值的下标和初始的i值不同,交换
		{
			DataType tmp=pSeq->Data[i];
			pSeq->Data[i]=pSeq->Data[min];
			pSeq->Data[min]=tmp;
		}
	}
}

int Binary_Search(pSeqList pSeq,DataType x)  
{  
    int left=0;  
    int mid=0;  
    int right=pSeq->size-1;  
    assert(pSeq);  
    Bubble_Sort(pSeq);     //二分查找必须是有顺序的一组元素  
    while(left < right)  
    {  
        mid=(left+right)/2;  
        if(pSeq->Data[mid] < x)  
        {  
            left=mid;  
        }  
        else if(pSeq->Data[mid] > x)  
        {  
            right=mid;  
        }  
        else  
        {  
            return mid;  
        }  
    }  
    return -1;  
}  

void Free_SeqList(pSeqList pSeq)
{
	free(pSeq->Data);
	pSeq->Data=NULL;
	exit(0);
}

          text.c
           
#include"SeqList_dyna.h"

void text()
{
	int x=0;  
    int input=1;  
    int pos=0;  
	int ret=0;
    SeqList pSeq;  
    Init_SeqList(&pSeq);  
    while(input)  
    {  
        menu();  
        printf("请选择一个你要进行的操作:");  
        scanf("%d",&input);  
        switch(input)  
        {  
        case 1:  
            printf("请输入一个你要插入的数据:");  
            scanf("%d",&x);  
            Push_Back(&pSeq,x);  
            break;  
        case 2:  
             Pop_Back(&pSeq);  
             break;  
        case 3:  
            printf("请输入一个你要插入的数据:");  
            scanf("%d",&x);  
            Push_front(&pSeq,x);  
            break;  
        case 4:  
            Pop_front(&pSeq);  
            break;  
        case 5:  
            printf("请输入一个你要插入的数据:");  
            scanf("%d",&x);  
            printf("请输入你要插入的位置:");  
            scanf("%d",&pos);  
            Insert_SeqList(&pSeq,pos,x);  
            break;  
        case 6:  
            printf("请输入一个你要删除的数据:");  
            scanf("%d",&x);  
            Remove_SeqList(&pSeq,x);  
            break;  
        case 7:  
            printf("请输入一个你要删除的数据:");  
            scanf("%d",&x);  
            RemoveAll_SeqList(&pSeq,x);  
            break;  
        case 8:  
            Bubble_Sort(&pSeq);  
            break;  
        case 9: 
			Insertion_Sort(&pSeq);
            break;  
        case 10:  
			Select_Sort(&pSeq);
			break;
		case 11:
			Print_SeqList(&pSeq); 
			break;
		case 12:
			printf("请输入一个你要查找的数据:");  
            scanf("%d",&x);  
            ret=Binary_Search(&pSeq,x);  
			if(pSeq.Data[ret] == x)
			{
				printf("查找成功\n");
			}
			else
			{
				printf("查找失败\n");
			}
			break;
        case 0: 
			Free_SeqList(&pSeq);
            break;  
        default:  
            printf("您的输入错误请重新选择\n");  
            break;  
        }  
    }  
}

int main()  
{  
	text();
    system("pause");  
    return 0;  
}

            在程序的实现过程中排序使用了三种方法:冒泡排序，直接插入排序和选择排序，实现可参见上述SeqList_dyna代码块中的函数实现。

顺序表的动态存储
chenjunshuo的博客
01-24 2083
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般分为： 1.静态顺序表：使用定长的数组存储； 2.动态顺序表：使用动态开辟的数组存储； 由于静态顺序表相对简单，我们便以动态顺序表为例来实现顺序表的相关接口； 首先是顺序表结构体的定义： 一般来说顺序表的结构体中主要包含：用于存储数据的数组，用于记录末尾数据下标（还能...
数据结构与算法学习笔记二---顺序表的动态分配存储表示和实现(C++)
我叫柱子哥
05-13 924
这篇文章讲的是线性表的动态分配存储表示。
【数据结构】顺序表的动态存储
weixin_45902047的博客
03-03 305
SeqList.h #include"SList.h" void TestSList() { //SListNode phead;//直接定义一个头节点？ //此时只需要一个指针即可，不需要结点！！！！ SListNode* pList = NULL;//因为头指针只有指针域没有数据域，这里只需要一个指针变量即可 SListPrint(pList); SListPushBack(&pList, 1); SListPushBack(&pList, 1); SListPushB
【数据结构】 动态存储的顺序表
Suk_god的博客
11-24 1417
文章目录顺序表的概念及结构分类1. 静态顺序表：使用定长数组存储元素。2.动态顺序表：使用动态开辟的数组存储。相关接口的实现动态开辟空间相关函数操作申明相关代码分享思考与总结1.顺序表的任意位置插入，时间复杂度高2.扩容消耗大3.扩容标准问题如何解决？ 顺序表的概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 分类 1. 静态顺序表：使用定长数组存储元素。 不常用，也不实用。需要根据情况提前确定容量。 2.动态顺序表：使用动态开
顺序表的动态存储细节
Bing's Blog
12-03 2138
顺序表的动态存储细节@(算法学习) 在顺序表的动态存储定义中需要包含的数据成员是（C） I. 数组指针 II. 表中元素个数n III. 表的大小maxSize IV. 数组基址base A. I 、II B. I 、II、IV C. I 、II、III D. 全部如果是在代码中写顺序表的动态存储方式，可能上手就知道要定义一个可动态增长的数组，通过malloc或者n
模拟通讯录-数据结构（顺序表实现基本功能）.doc
04-25
在本项目中，我们以“模拟通讯录-数据结构（顺序表实现基本功能）”为主题，探讨如何利用数据结构和C++编程语言来构建一个简易的通讯录系统。该系统应具备通讯录的建立、联系人添加、删除、修改以及查找等基本功能，...
02-顺序表-SeqList.c
最新发布
04-17
在计算机科学中，顺序表是一种线性表的实现方式，通常使用连续的内存空间来存储数据元素。在C语言的编程环境中，顺序表可以通过数组结构来模拟实现。文件名为“02-顺序表-SeqList.c”，可能是一个C语言实现顺序表的...
C语言实验-动态顺序表实现简易通讯录
wyd_333的博客
10-08 5878
C语言数据结构顺序表的应用：简易通讯录
数据结构实验报告1-顺序表实现简易的学生信息管理系统(C语言)
04-07
本实验报告主要探讨了如何使用C语言中的顺序表来实现一个简易的学生信息管理系统。该系统能够对学生的学号、姓名和成绩等信息进行管理，具体实现了以下功能： 1. **根据指定的学生个数逐个输入学生信息；** 2. **...
JAVA模拟新增顺序表及单链表
08-18
JAVA模拟新增顺序表及单链表 ...本文介绍了Java语言中模拟新增顺序表及单链表的实现，包括顺序表的自动扩容、单链表的实现、Node类的实现等知识点，这些知识点对于学习和工作具有重要的参考价值。
数据结构中顺序表存储结构的演示
05-09
这是数据结构中关于顺序表这个知识点的一个实验的演示，是使用C++实现的，希望能够对学习数据结构中的关于顺序表存储的朋友有用。
数据结构与算法学习笔记二---顺序表的动态存储表示和实现(C语言)
我叫柱子哥
05-13 506
这篇博客主要是顺序表的动态分配存储表示。
模拟实现顺序表
YANG
05-25 394
顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。
D24. 顺序表的动态存储
canvasa的博客
06-26 162
// 顺序表的动态存储 #ifndef _SEQLIST_H_ #define _SEQLIST_H_ #include<stdio.h> #include<stdlib.h> #include<assert.h> typedef int SLDataType; //相当于给int起一个datatype的别称，及datatype就是int typede...
顺序表（动态）
L_R
09-13 418
上篇博客介绍了静态顺序表的增删查改以及排序，我们知道了: 静态顺序表的长度是固定的，但是如果我们在使用顺序表是并不知道顺序表的长度，或者在使用过程中，顺序表的长度不够了，难道我们要重新再创建一个新的顺序表吗？这样显然是很麻烦的。所以本篇博客将讨论动态顺序表。 那么动态顺序表和静态顺序表又有什么区别呢？ 上面我们提到了静态顺序表的局限性，那么动态顺序表很有效的解决了静态的不足之处，当在使用顺序...
java模拟实现顺序表
zjychl的博客
05-04 983
1.属性设置 import java.util.ArrayList; import java.util.Arrays; public class MyArraylist { public int[]arr; public int usedSize;//有效数据 private static final int DEFAULT_SIZE=4;//默认值 public MyArraylist() { this.arr=new int[DEFAULT_SIZE
顺序表功能的模拟实现
mignatian的博客
03-15 350
今天学习了顺序表，对里面的知识有所了解，想通过自己的努力实现一下自己的顺序表首先我们要写一个头文件，包含我们所有要实现的功能#pragma once #define HEADER printf("\n------------%s-----------\n",__FUNCTION__) #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define ...
【数据结构】动态顺序表
码农印象
06-24 626
前言： 对于初学数据结构的新手来说，第一步都是从线性表学起，我们都知道线性表是：具有n个数据元素的有限序列，且能进行增删改查操作的一种线性数据结构。而根据数据元素在存储单元中存储的方式不同又分为顺序表与链表。顺序表就是用一段地址连续的存储单元存储数据，我们大多选用的都是数组，而对于数组可分为静态数组与动态数组，所以顺序表又可分为静态顺序表与动态顺序表。 今天来一起学习的是：动态顺序表的...
顺序表(线性表的顺序存储结构)及C语言实现
热门推荐
暗夜
02-06 2万+
逻辑结构上呈线性分布的数据元素在实际的物理存储结构中也同样相互之间紧挨着，这种存储结构称为线性表的顺序存储结构。 也就是说，逻辑上具有线性关系的数据按照前后的次序全部存储在一整块连续的内存空间中，之间不存在空隙，这样的存储结构称为顺序存储结构。 使用顺序存储结构存储的数据，第一个元素所在的地址就是这块存储空间的首地址。通过首地址，可以轻松访问到存储的所有的数据，只要首地址不丢，数据永远
C++实现动态顺序表详解及代码实例
"C++ 实现动态顺序表的代码示例" 在编程中，动态顺序表是一种常见的数据结构，它允许在表的中间插入和删除元素，同时能够自动调整其容量以适应元素数量的变化。在 C++ 中，我们可以使用类来实现这种数据结构，通常...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值