栈、队列的应用(栈实现队列，队列实现栈，球钟问题）

已于 2022-05-20 19:35:54 修改
阅读量310 收藏
点赞数 1
分类专栏： 数据结构与算法 Linux-c 文章标签： 链表 c语言 数据结构
于 2022-05-20 19:18:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45698138/article/details/124889120
版权

栈、队列的应用 C语言

文章目录

1.用两个栈来实现一个队列

1.两个栈，s1，s2
2.入队：找到空s1栈，入栈，若无空栈，则出栈s1中的所有元素，存到另一栈s2中，再入栈s1。
3.出队：非空栈出栈。

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int DataType;

//数据节点结构体
typedef struct node
{
	DataType data;		//数据
	struct node *next;	//指针
}LinkNode;

//管理结构体
typedef struct stack
{
	struct node *top;		//栈顶偏移 栈顶指针就是节点指针的类型
	unsigned int size;				//当前元素个数
}Stack;


//初始化链式栈
Stack * InitStack()
{
	Stack * s = malloc(sizeof(Stack));
	if(s!=NULL)
	{
		s->top=NULL;
		s->size=0;
		return s;
	}
}

// 压栈、出栈、栈空判断
bool IsStackEmpty(Stack *s)
{
	return (s->size == 0);
}

bool push(Stack *s,DataType data)
{
	LinkNode *newNode = malloc(sizeof(LinkNode));
	if(newNode!=NULL)
	{
		//新节点初始化
		newNode->data = data;
		//新节点next指向原来栈顶
		newNode->next = s->top;
		//将栈顶设置为新节点
		s->top=newNode;
		//元素个数加1
		s->size++;
		return true;
	}
	return false;
}


bool pop(Stack *s,DataType *data)
{
	if(IsStackEmpty(s)||s==NULL)
	{
		return false;
	}
	//先拿到栈顶的数据
	*data = s->top->data;
	//将栈顶往后（向下）偏移一个
	s->top = s->top->next;
	//长度减1
	s->size--;
	return true;

}

void DisplayStack(Stack *s)
{
	LinkNode *tmp=s->top;
	int data;
	while(tmp!=NULL)
	{
		data = tmp->data;
		printf("%d ",data);
		tmp=tmp->next;
	}
	printf("\n");
}


void Stack_2_EnQueue(Stack *s1,Stack *s2,DataType data)
{	
	int tmp;
	while(!IsStackEmpty(s2))
	{
		pop(s2,&tmp);
		push(s1,tmp);
	}
	push(s1,data);
}
void Stack_2_DeQueue(Stack *s1,Stack *s2,DataType *data)
{
	int tmp;
	while(!IsStackEmpty(s1))
	{
		pop(s1,&tmp);
		push(s2,tmp);
	}
	pop(s2,data);
}
void QueueDisplay(Stack *s1,Stack *s2)
{
	if(IsStackEmpty(s1))
		DisplayStack(s2);
	else
		DisplayStack(s1);
}

int main(int argc, char const *argv[])
{
	Stack *s1=InitStack();
	Stack *s2=InitStack();

	int num;
	DataType data;
	int mem = 0;
	while(1)
	{
		scanf("%d", &num);
		if (num > 0)
		{
			mem++;
			Stack_2_EnQueue(s1,s2, num);
			QueueDisplay(s1,s2);
		}
		else
			if (num < 0)
			{
				mem--;
				Stack_2_DeQueue(s1,s2, &data);
				printf("出队：%d\n", data);
				QueueDisplay(s1,s2);
			}
			else
			{
				for (int i = 0; i < mem; ++i)
				{
					Stack_2_DeQueue(s1,s2, &data);
					printf("%d ", data);
				}
				mem = 0;
				printf("\n");			
			}
	}
	return 0;
}
2.用两个队列来实现一个栈

1.两个队列q1，q2
2.入栈：若找到空队列q1，入队，否则清空队列q1，将元素存到q2，再入队q1.
3.出栈：非空队列出队。

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int DataType;


//队列节点
typedef struct node
{
	DataType data;
	struct node *next;
}LinkNode;

//管理结构体
typedef struct
{
	struct node *front;		//队头指针
	struct node *rear;		//队尾指针
	unsigned int size;		//当前元素个数
}LinkQueue;


//初始化
LinkQueue *InitLinkQueue(void)
{
	LinkQueue *q=(LinkQueue *)malloc(sizeof(LinkQueue));
	if(q!=NULL)
	{
		q->front=NULL;
		q->rear=NULL;
		q->size=0;
		return q;
	}
	return q;
}

//判断队空
bool IsQueueEmpty(LinkQueue *q)
{
	return (q->size == 0);
}

LinkNode *CreatNode(DataType data)
{
	LinkNode * newNode = (LinkNode *)malloc(sizeof(LinkNode));
	if(newNode!=NULL)
	{
		newNode->data=data;
		newNode->next=NULL;
		return newNode;
	}
}

//入队
bool EnQueue(LinkQueue *q,LinkNode *newNode)
{
	if(newNode == NULL)
		return false;
	if(IsQueueEmpty(q))
	{
		//第一个数据进来，那么队头和队尾都指向这个节点
		q->front=newNode;
		q->rear=newNode;
	}
	else
	{
		//将新节点按照链表尾插的方式加入链表
		q->rear->next = newNode;
		//new就要作为队的新队尾节点
		q->rear = newNode;
	}
	q->size++;
	return true;
}


//出队
bool DeQueue(LinkQueue *q,LinkNode **nodeData)
{
	if(IsQueueEmpty(q))
		return false;

	//将队头的数据拿到
	*nodeData = q->front;
	//队头要重新变到下一个节点
	q->front=q->front->next;
	q->size--;
	return true;
}

bool DeQueue1(LinkQueue* q, DataType *data)
{
	//队列为空
	if (IsQueueEmpty(q))
	{
		return false;
	}

	if (q->size == 1)
	{
		q->rear = NULL;
	}

	//将队头的数据拿到
	*data = q->front->data;
	//队头要重新变到下一个节点
	q->front = q->front->next;
	q->size--;
	return true;
}


//遍历链表
void Display(LinkQueue *q)
{
	LinkNode *tmp=q->front;
	while(tmp != NULL)
	{
		printf("%d ",tmp->data);
		tmp=tmp->next;
	}
	printf("\n");
}


void Queue_2_Push(LinkQueue *q1,LinkQueue *q2,DataType data)
{
	LinkNode *tmp=NULL;
	if(IsQueueEmpty(q1))
	{
		EnQueue(q1,CreatNode(data));
		while(!IsQueueEmpty(q2))
		{
			DeQueue(q2,&tmp);
			EnQueue(q1,CreatNode(tmp->data));
		}
	}
	else
	{
		EnQueue(q2,CreatNode(data));
		while(!IsQueueEmpty(q1))
		{
			DeQueue(q1,&tmp);
			EnQueue(q2,CreatNode(tmp->data));
		}
	}

}
void Queue_2_Pop(LinkQueue *q1,LinkQueue *q2,DataType *data)
{
	LinkNode *tmp=NULL;
	if(!IsQueueEmpty(q1))
	{
		DeQueue(q1,&tmp);
	}
	else
	{
		DeQueue(q2,&tmp);
	}
	*data=tmp->data;

}

void DisplayStack(LinkQueue *q1,LinkQueue *q2)
{
	if(IsQueueEmpty(q1))
		Display(q2);
	else
		Display(q1);
}



int main(int argc, char const *argv[])
{
	LinkQueue *q1 = InitLinkQueue();
	LinkQueue *q2 = InitLinkQueue();



	int num;
	DataType data;
	int mem = 0;
	while(1)
	{
		scanf("%d", &num);
		if (num > 0)
		{
			mem++;
			Queue_2_Push(q1,q2, num);
			DisplayStack(q1,q2);
		}
		else
			if (num < 0)
			{
				mem--;
				Queue_2_Pop(q1,q2, &data);
				printf("出栈：%d\n", data);
				DisplayStack(q1,q2);
			}
			else
			{
				for (int i = 0; i < mem; ++i)
				{
					Queue_2_Pop(q1,q2, &data);
					printf("%d ", data);
				}
				mem = 0;
				printf("\n");			
			}
	}

	return 0;
}
3.球钟问题

球钟问题描述:球钟是一个利用球的移动来记录时间的简单装置。它有三个可以容纳若干个球的指示器：分钟指示器，五分钟指示器，小时指示器。若分钟指示器中有2个球，5分钟指示器中有6个球，小时指示器中有5个球，则时间为5:32。

在这里插入图片描述

​ 工作原理:每过一分钟，球钟就会从球队列的队首取出一个球放入分钟指示器，分钟指示器最多可容纳4个球。当放入第五个球时，在分钟指示器的4个球就会按照他们被放入时的相反顺序加入球队列的队尾。而第五个球就会进入分钟指示器。按此类推，五分钟指示器最多可放11个球，小时指示器最多可放11个球。当小时指示器放入第12个球时，原来的11个球按照他们被放入时的相反顺序加入球队列的队尾，然后第12个球也回到队尾。这时，三个指示器均为空，回到初始状态，从而形成一个循环。因此，该秋种表示的时间范围是从00:00到11:59

要想表示00:00到12：00需要多少个球?假设，指示器都为空，球队列需要多长时间能回到原来的状态?

1.定义1个队列q，3个栈s1，s5，s60
2.s1存4个元素判断栈满然后入栈s5，将s1所有元素出栈，入队q
3.s5存11个元素判断栈满然后入栈s60，将s5所有元素出栈，入队q
4.s60存11个元素判断栈满，将s60所有元素出栈，入队q
5.判断q中的元素顺序

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include <time.h>

typedef int DataType;

//数据节点结构体
typedef struct node
{
	DataType data;		//数据
	struct node *next;	//指针
}LinkNode;


//管理结构体
typedef struct queue
{
	struct node *front;		//队头指针
	struct node *rear;		//队尾指针
	unsigned int size;		//当前元素个数
}LinkQueue;


//管理结构体
typedef struct stack
{
	struct node *top;		//栈顶偏移 栈顶指针就是节点指针的类型
	int size;				//当前元素个数
}Stack;


//初始化
LinkQueue *InitLinkQueue(void)
{
	LinkQueue *q=(LinkQueue *)malloc(sizeof(LinkQueue));
	if(q!=NULL)
	{
		q->front=NULL;
		q->rear=NULL;
		q->size=0;
		return q;
	}
	return q;
}

//判断队空
bool IsQueueEmpty(LinkQueue *q)
{
	return (q->size == 0);
}

LinkNode *CreatNode(DataType data)
{
	LinkNode * newNode = (LinkNode *)malloc(sizeof(LinkNode));
	if(newNode!=NULL)
	{
		newNode->data=data;
		newNode->next=NULL;
		return newNode;
	}
}

//入队
bool EnQueue(LinkQueue *q,LinkNode *newNode)
{
	if(newNode == NULL)
		return false;
	if(IsQueueEmpty(q))
	{
		//第一个数据进来，那么队头和队尾都指向这个节点
		q->front=newNode;
		q->rear=newNode;
	}
	else
	{
		//将新节点按照链表尾插的方式加入链表
		q->rear->next = newNode;
		//new就要作为队的新队尾节点
		q->rear = newNode;
	}
	q->size++;
	return true;
}


//出队
bool DeQueue(LinkQueue *q,LinkNode **nodeData)
{
	if(IsQueueEmpty(q))
		return false;

	//将队头的数据拿到
	*nodeData = q->front;
	//队头要重新变到下一个节点
	q->front=q->front->next;
	q->size--;
	return true;
}

bool DeQueue1(LinkQueue* q, DataType *data)
{
	//队列为空
	if (IsQueueEmpty(q))
	{
		return false;
	}

	if (q->size == 1)
	{
		q->rear = NULL;
	}

	//将队头的数据拿到
	*data = q->front->data;
	//队头要重新变到下一个节点
	q->front = q->front->next;
	q->size--;
	return true;
}


//遍历链表
void DisplayQueue(LinkQueue *q)
{
	int flag=0;
	LinkNode *tmp=q->front;
	while(tmp != NULL)
	{
		printf("%s%d",flag == 0?"":"-",tmp->data);
		flag=1;
		tmp=tmp->next;
	}
	printf("\n");
}


Stack * InitStack()
{
	Stack * s = malloc(sizeof(Stack));
	if(s!=NULL)
	{
		s->top=NULL;
		s->size=0;
		return s;
	}
}

bool IsStackEmpty(Stack *s)
{
	return (s->size == 0);
}

bool push(Stack *s,DataType data)
{
	LinkNode *newNode = malloc(sizeof(LinkNode));
	if(newNode!=NULL)
	{
		//新节点初始化
		newNode->data = data;
		//新节点next指向原来栈顶
		newNode->next = s->top;
		//将栈顶设置为新节点
		s->top=newNode;
		//元素个数加1
		s->size++;
		return true;
	}
	return false;
}


bool pop(Stack *s,DataType *data)
{
	if(IsStackEmpty(s)||s==NULL)
	{
		return false;
	}
	//取出数据
	*data = s->top->data;
	//栈顶偏移指向上一个节点
	s->top = s->top->next;
	s->size--;
	return true;

}

void DisplayStack(Stack *s)
{
	LinkNode *tmp=s->top;
	int data;
	while(tmp!=NULL)
	{
		data = tmp->data;
		printf("%d ",data);
		tmp=tmp->next;
	}
	printf("\n");
}

void Stack_pop_Enque(Stack *s,LinkQueue *q)
{
	int data;
	while(!IsStackEmpty(s))
	{
		pop(s,&data);
		EnQueue(q,CreatNode(data));
	}
}
bool CheckQueue(LinkQueue *q)
{
	if(IsQueueEmpty(q))
		return false;
	LinkNode *p=q->front;
	while(p->next!=NULL)
	{
		if(p->data > p->next->data)
		{
			return false;
		}
		p = p->next;
	}
	return true;
}

void show(Stack *s1,Stack *s5,Stack *s60,LinkQueue *q)
{
	system("clear");
	printf("s1\ts5\ts60\n");
	LinkNode *tmp1=s1->top;
	LinkNode *tmp5=s5->top;
	LinkNode *tmp60=s60->top;
	for(int i=1;i<12;i++)
	{
		if (tmp1!=NULL)
		{
			printf("%d", tmp1->data);
			tmp1=tmp1->next;
		}
		printf("\t");
		if (tmp5!=NULL)
		{
			printf("%d", tmp5->data);
			tmp5=tmp5->next;
		}
		printf("\t");
		if (tmp60!=NULL)
		{
			printf("%d", tmp60->data);
			tmp60=tmp60->next;
		}
		printf("\n");
	}
	DisplayQueue(q);
}

int main(int argc, char const *argv[])
{
	int tmp;
	int balls=27,i;
	int minutes=0;
	LinkQueue *q;
	Stack *s1,*s5,*s60;

	q = InitLinkQueue();
	s1 = InitStack();
	s5  = InitStack();
	s60 = InitStack();

	for(i=1;i<=balls;i++)
		EnQueue(q,CreatNode(i));
	
	// printf("%d",q->size);

	while(1)
	{
		show(s1,s5,s60,q);
		DeQueue1(q,&tmp);//出队一个球
		minutes++;
		usleep(1000*200);

		if(s1->size != 4) //栈没满，往里面放球
		{
			push(s1,tmp);
		}
		else
		{
			Stack_pop_Enque(s1,q);//球出栈入队
			if(s5->size!= 11)//栈没满，往里面放球
			{
				push(s5,tmp);
			}
			else
			{
				Stack_pop_Enque(s5,q);//球出栈入队
				if(s60->size!=11)
				{
					push(s60,tmp);
				}
				else
				{
					Stack_pop_Enque(s60,q);//球出栈入队
					EnQueue(q,CreatNode(tmp));//球入队
					if(CheckQueue(q))//球的顺序又变为了从小到大的顺序之后
						break;
				}
			}
		}			
		
	}
		
	printf("%d\n",minutes);
	


	return 0;
}

在这里插入图片描述
33120

Yengi
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
栈和队列的基本操作实现及其应用
remain_genuine的博客
04-26 1272
实验2：栈和队列的基本操作实现及其应用一、实验目的1、   熟练掌栈和队列的结构特点，掌握栈和队列的顺序存储和链式存储结构和实现。2、      学会使用栈和队列解决实际问题。二、实验内容1、自己确定结点的具体数据类型和问题规模：分别建立一个顺序栈和链栈，实现栈的压栈和出栈操作。分别建立一个顺序队列和链队列，实现队列的入队和出队操作。顺序栈#include&lt;iostream&gt;  usi...
【栈与队列】——栈的实现及应用
热门推荐
诺诺的包包
12-23 2万+
【C语言】栈的实现及括号匹配问题的应用
数据结构-栈（Stack）和队列（Queue）的实现以及应用（深入浅出）
qq_39225639的博客
08-30 523
数据结构-栈结构和队列结构栈（Stack）栈的特性相关名词栈的实现生活中的栈队列（Queue）队列的特性生活中的队列 栈结构和队列是比较常见的受限的线性结构 栈（Stack） 栈的特性 限定仅仅在表尾进行插入和删除的操作的线性表，这一端称为栈顶。相对的另一端称之为栈底。 原则：后进先出原则 相关名词 进栈(push)：压入 出栈(pop):弹出 栈的实现 栈的常见操作 push 压入元素到栈顶 pop 弹出栈顶元素 peek 返回栈顶的元素 isEmpty 判断栈是否为空 size 返回栈的元
栈和队列应用-钟球问题
03-22
球钟是一个利用球的移动来记录时间的简单装置 它有三个可以容纳若干个球的指示器：分钟指示器，五分钟指示器，小时指示器 若分钟指示器中有2个球，五分钟指示器中有6个球，小时指示器中有5个球，则时间为5:32 工作...
利用队列和栈解决球钟问题
09-13
通过队列与栈解决球钟问题。球钟问题是：分钟指示器最多容纳4个球，5分钟指示器最多容纳11个球，小时计时器最多容纳11个球。还有一个包含27个球的队列，每分钟向分钟计时器输送一个球，如果满，分钟计时器内的球倒序...
如何使用两个栈实现队列Java
08-25
主要介绍了如何使用两个栈实现队列Java,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Python 实现数据结构中的的栈队列
09-19
主要介绍了Python 实现数据结构中的的栈，队列,本文给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
Python实现栈和队列的简单操作方法示例
09-18
主要介绍了Python实现栈和队列的简单操作方法,结合实例形式详细分析了Python栈和队列的原理与简单实现技巧,需要的朋友可以参考下
用栈来表示队列，用队列来表示栈
apple3515的博客
03-19 161
这个问题总的栈和队列，没有自己手写，自己手写太浪费了，于是就用的java中的集合框架list下面的LinkedList 其实LinkedList既可以当做栈用，也可以当做队列来使用. 作为栈的时候，LinkedList<T> stack = newLinkedList<T>().入栈stack.push(e),出栈stack.pop() 作为队列时，Lin...
笔记:栈与队列的应用
Polaris17877的博客
01-06 332
​ 一、栈应用： 括号匹配： 当读入第1个左括号时，期待下一个出现的右括号与第1个左括号匹配，若读入第2个左括号，则期待下一个出现的右括号与第2个左括号匹配…读入第n个左括号，则期待下一个出现的右括号与第n个左括号匹配，匹配成功后，期待下一个右括号与第n-1个左括号匹配…直到所有的左括号全被匹配完成，处理过程与栈思想吻合，因此算法思想如下： 设置一个空栈，顺序读入括号 若是左括号，压入栈 若是右括号，则与栈顶的左括号匹配，不匹配或栈空则报错，匹配则弹出栈顶元素 没有括号匹配，则检查栈是否为空
栈和队列的实现和总结
m0_72873854的博客
11-23 1145
栈和队列的总结
【数据结构】栈和队列的实现及应用
学了就忘是正常现象
08-18 3350
栈和队列
如何用栈表示队列
m0_65467013的博客
05-13 276
首先我们应该知道什么是栈，什么是队列以及各自的特点。 栈：Stack栈，它仅允许在一端进行插入和删除操作，这一端被称为栈顶，相对地，另一端位栈 底。向一个栈插入新元素叫做进栈（push），他是把元素放入栈顶元素的上面，使之成为新的栈顶元素：从一个栈中删除元素叫做出栈（pop），它是把栈顶元素删除掉，使其下一位成为栈顶元素。栈的特点：后进先出（先进栈的被压进栈底，后进栈的依次为栈顶元素）。下图所示。 ...
栈、队列及其应用
m0_63949203的博客
05-02 458
实验三 栈、队列及其应用 一、实验目的： （1）掌握顺序栈操作的初始化、入栈、出栈、取栈顶元素算法； （2）掌握栈的应用算法----进制转换及表达式求值； （3）理解链栈的初始化、入栈、出栈、取栈顶元素算法； （4）了解循环队列结构及初始化、入队、出队、取队头元素等操作； 二、实验原理 栈 1.定义 只能在一端（栈顶）进行插入和删除操作的线性表。 2.逻辑结构 与线性表相同，仍为一对一关系。 3.储存结构 用顺序栈或链栈储存均可，但以顺序栈更常见。 4.运算规则 只能在栈顶运算，且访问结点时依照后进先出。
栈实现队列(队列实现栈)
weixin_55742319的博客
01-14 3012
数据结构与算法应用(栈与队列互相实现)
数据结构之循环队列和栈的应用
摩尔的博客
06-25 1452
前面提到，在队列的顺序存储结构中，必须要讨论顺序队列的数组越界（或上溢）问题。根据顺序队列的定义，我们可以很轻松的发现，当队列删除一个元素之后，即front指针向后移动之时，往往这个时候就有可能出现所谓的“假溢出”现象，即可能会出现下图所示这般：解决“假溢出”的办法有很多，其中最为出色的是这四种方法： 一、采用循环队列 二、按最大可能的进队操作次数设计顺序队列的最大元素个数 三、修改出队算法，
栈和队列
liusiyu
04-17 104
一.栈 1.1 栈的概念 栈就是一种特殊的线性表，只允许固定的一端进行插入和删除元素的操作，进行数据的插入删除操作的一端称为栈顶,另一端称为栈底 栈中的数据元素遵守 后进先出 LIFO的原则 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶 出栈：栈的删除操作叫做出栈，出数据在栈顶 1.2 实现 用顺序表实现栈 public class MyStack { private int...
 数据结构栈和队列实现的问题
最新发布
05-31
栈和队列都是常见的数据结构，栈是一种后进先出（LIFO）的数据结构，而队列是一种先进先出（FIFO）的数据结构。 栈可以用数组或链表来实现，基本操作有入栈（push）、出栈（pop）、查看栈顶元素（peek）等。入栈操作将元素添加到栈顶，出栈操作从栈顶弹出元素，查看栈顶元素则返回栈顶元素的值。 队列也可以用数组或链表来实现，基本操作有入队（enqueue）、出队（dequeue）、查看队首元素（front）等。入队操作将元素添加到队尾，出队操作从队首弹出元素，查看队首元素则返回队首元素的值。 需要注意的是，在使用数组实现栈和队列时，需要考虑数据溢出的情况，而链表实现则不会有这个问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Yengi

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值