【数据结构】栈与队列OJ - 精选精讲

已于 2023-11-24 21:10:35 修改
阅读量101 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 算法 c++ c语言
于 2023-11-24 21:09:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bubble_shadow/article/details/134606774
版权

文章目录

前言

本文选取了一些经典的来自力扣的有关栈与队列的OJ题，致力于帮助读者巩固相关知识概念，并提供优质，值得借鉴的思路供读者积累与掌握。

一、注意事项

  1. 使用C语言实现，大部分题目使用了相应的事先准备好的接口函数，读者可以直接复制粘贴自己敲过的接口函数在OJ题提供的代码上方即可。
  2. 确保接口函数100%正确，如果确定代码逻辑正确，仍报错，极有可能是接口函数写错了，这是一个极好的检验知识是否掌握的机会。

二、OJ精析

  1. 括号匹配问题

在这里插入图片描述

  • 思路讲解
  1. 读题：有效括号包括两部分，顺序相同和数量相同。
  2. 实现：
  1. 顺序相同：
    利用栈后进先出的特点，读取字符串s，遇到左括号就进栈，遇到右括号就出栈查看是否为匹配的左右括号
  2. 数量相同：
    遇到右括号时，查看栈是否为空，为空说明右括号多余；
    字符串读取完时，查看栈是否为空，不为空说明左括号有剩余
  • 代码实现
typedef char StackDataType;

typedef struct Stack
{
	StackDataType* a;
	int top;  //栈顶下标
	int capacity; //空间容量
}Stack;

//创建并初始化
void StackInit(Stack* ps)
{
	assert(ps);

	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

//销毁
void StackDestory(Stack* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;

}

//入栈
void StackPush(Stack* ps, StackDataType x)
{
	assert(ps);

	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		//注意是数组，指针类型为存放数据的类型
		StackDataType* tmp = (StackDataType*)realloc(ps->a,sizeof(StackDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;  //在栈顶后插入
	ps->top++;
}

//出栈
void StackPop(Stack* ps)
{
	assert(ps);
	//不为空
	assert(ps->top > 0);
	ps->top--;  //并没有真的“扔出”，只是不再访问这个位置的数据
}

//获取栈顶元素值
StackDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);  //栈顶大于0才拥有有效元素
	return ps->a[ps->top - 1];
}

//获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

//检测栈是否为空
bool StackEmpty(Stack* ps)  //布尔类型，需包含头文件<stdbool.h>
{
	assert(ps);
	return ps->top == 0;  //利用表达式返回值，如果表达式为真，则返回ture，否则返回false。
}

bool isValid(char* s) {
	//创建栈并初始化
    Stack a;
    StackInit(&a);
    
    /*while判断顺序是否匹配*/
	while (*s)
	{
		//当访问的s为左括号时进栈
		if (*s == '(' || *s == '{' || *s == '[')
			StackPush(&a, *s);

		//否则保存栈顶值，判断是否为匹配左括号的三个右括号，不为时返回false
		else
		{
			/*如果为空，说明右括号多于，数量不匹配*/
			if (StackEmpty(&a))
			{
                StackDestory(&a);
				return false;
			}
			//栈里面取左括号，此时*s里面应为右括号
			char top = StackTop(&a);
			StackPop(&a);
			//连续&& 和 || 可以一行写一个判断，且将操作符放行头，可以直接对齐
			if ((*s == ')' && top != '(')
			|| (*s == '}' && top != '{')
			|| (*s == ']' && top != '['))
                {
                    StackDestory(&a);
				    return false;
                }
		}
		++s;
	}
/*
	if (StackEmpty(&a))
		 {
			StackDestory(&a);
			 return true;
		 }
	 return false; 
*/
	 //利用bool类型精简代码
	 /*如果不为空，说明左括号多于，数量不匹配*/
	bool ret = StackEmpty(&a);
	StackDestory(&a);
	return ret;
    
}

  2. 用队列实现栈

在这里插入图片描述

  • 思路讲解

重点：满足栈后进先出的性质即可
整体：空队列倒数据，非空队列存数据，初始均为空时随便。
（删除时将不需要删除的数据由非空队列转存进空队列，再删除剩下的即可）
注意点：
1.每次删除（模拟出栈）非空队列和空队列会互换，不是固定的，用假设法判断空与非空非常方便。
2.注意销毁模拟栈时，记得先销毁队列。

  • 代码实现
typedef int QueueDataType;

typedef struct QueueNode
{
	QueueDataType val;
	struct QueueNode* next;

}QNode;

typedef struct
{
	QNode* phead;  //头指针
	QNode* ptail;  //尾指针
	int size;	   //队内有效元素个数

}Queue;


//创建并初始化（使用的是无头单链表，这里不需要开辟节点，初始化新定义的结构体即可）
void QueueInit(Queue* pq)  
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

//销毁
void QueueDestory(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->phead;
	
	while (cur)
	{
		QNode* tmp = cur;
		cur = cur->next;
		free(tmp);
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

//队尾入队（插入）
void QueuePush(Queue* pq,QueueDataType x)
{
	assert(pq);
	//只有插入需要开辟空间，不需要单独写一个接口
	//1.开辟新节点，检验成功后初始化
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->val = x;
	newnode->next = NULL;

	//2.分情况插入 - 为空；不为空
	if (pq->phead == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++; //更新有效元素个数
}

//队头出队（删除）
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->phead);  //为空时不能再出栈了

	QNode* tmp = pq->phead;
	pq->phead = pq->phead->next;
	free(tmp);
	//仅有一个节点时，需要置空尾指针
	if (pq->phead == NULL)
		pq->ptail = NULL;

	pq->size--; //更新有效元素个数

}

//获取队头元素值
QueueDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->phead); //为空时没有元素，不能访问队头

	return pq->phead->val;
}

//获取队尾元素值
QueueDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail); //为空时没有元素，不能访问队尾
	
	return pq->ptail->val;
}

//获取队列中有效元素个数
int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

//检查队列是否为空
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->phead == NULL;  //利用表达式返回值，表达式为真则返回1，为假则返回0
}

//                      以上为队列接口
typedef struct {
    Queue q1;
    Queue q2;

} MyStack;


MyStack* myStackCreate() {
    //无论是数组还是链表，我们定义创建接口时都并未开辟空间，只是定义一个外壳，这里的接口函数要求我们一步到位，创建并开辟空间
    //开辟整体空间，创建结构体指针
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    //创建初始化队列
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);
    return obj;
}

void myStackPush(MyStack* obj, int x) {
    //一个队列专门存，一个队列专门倒
    //存数据的就一直存，所以存进非空队列，初始时随便选一个队列存入作为存队列
    if(!QueueEmpty(&obj->q2))
        QueuePush(&obj->q2,x);
    else
    {
        QueuePush(&obj->q1,x);
    }
}

int myStackPop(MyStack* obj) {
    //假设法精简代码，不用动脑子自己判断哪个是存队列，哪个是转队列
    Queue* empty = &obj->q2;
    Queue* unempty = &obj->q1;
    if(!QueueEmpty(&obj->q2))
    {
        empty = &obj->q1;
        unempty = &obj->q2;
    }
    //将不需要删除的元素由非空转入空
    while(unempty->phead != unempty->ptail)
    //while(QueueSize(unempty)>1)
    {
        QueuePush(empty,QueueFront(unempty));
        QueuePop(unempty);
    }
    int top = QueueFront(unempty);
    QueuePop(unempty);
  
    return top;
}

int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&obj->q1))
        return QueueBack(&obj->q1);
    else
    {
        return QueueBack(&obj->q2);

    }
}

bool myStackEmpty(MyStack* obj) {
    //两个都为假才为假
    return (QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2));
}

void myStackFree(MyStack* obj) {
    //注意队列的销毁，free只是把模拟栈内的存放链表指针的结构体释放了，但指针指向的链表是不会被释放的
    QueueDestory(&obj->q2);
    QueueDestory(&obj->q1);
    free(obj);
    obj == NULL;
}

  3. 用栈实现队列

在这里插入图片描述

  • 思路讲解

整体：利用栈接口，整体思路同队列模拟栈，实现队列先进先出的性质即可。
思路：一个栈专门存数据，一个栈专门删数据，获取数据。两个栈功能恒定不变，实现比模拟队列容易理解。

  • 代码实现
typedef int StackDataType;

typedef struct Stack
{
	StackDataType* a;
	int top;  //栈顶下标
	int capacity; //空间容量
}Stack;

void StackInit(Stack* ps)
{
	assert(ps);

	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

//销毁
void StackDestory(Stack* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;

}

//入栈
void StackPush(Stack* ps, StackDataType x)
{
	assert(ps);

	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		//注意是数组，指针类型为存放数据的类型
		StackDataType* tmp = (StackDataType*)realloc(ps->a, sizeof(StackDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;  //在栈顶后插入
	ps->top++;
}

//出栈
void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);
	ps->top--;  //并没有真的“扔出”，只是不再访问这个位置的数据
}

//获取栈顶元素值
StackDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);  //栈顶大于0才拥有有效元素
	return ps->a[ps->top - 1];
}

//获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

//检测栈是否为空
bool StackEmpty(Stack* ps)  //布尔类型，需包含头文件<stdbool.h>
{
	assert(ps);
	return ps->top == 0;  //利用表达式返回值，如果表达式为真，则返回ture，否则返回false。
}

            //以上为栈接口

typedef struct {
    Stack s1;
    Stack s2;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&obj->s1);
    StackInit(&obj->s2);
    return obj;
}

void myQueuePush(MyQueue* obj, int x) {
    StackPush(&obj->s1,x);
}

int myQueuePeek(MyQueue* obj) {
    //不为空直接获取s2栈顶
    if(!StackEmpty(&obj->s2))
    {
        return StackTop(&obj->s2);
    }
    //否则先从s1倒数据到s2
    while(obj->s1.top>0)
    {
        StackPush(&obj->s2,StackTop(&obj->s1));
        StackPop(&obj->s1);
    }
    return StackTop(&obj->s2);
}

int myQueuePop(MyQueue* obj) {
    int top = myQueuePeek(obj);
    StackPop(&obj->s2);
    return top;
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->s1) && StackEmpty(&obj->s2);
}

void myQueueFree(MyQueue* obj) {
    StackDestory(&obj->s1);
    StackDestory(&obj->s2);
    free(obj);
}

  4. 设计循环队列

在这里插入图片描述

  • 思路讲解

数组队列实现，不使用接口。
重点：

  1. 判断为空和为满（为空时back == front；满时back+1 == front，注意数学取模方法）
  2. 涉及下标操作都要进行数学取模使下标在处于尾部时能循环回头部（循环队列空间恒定不变）

数学取模思想：
适用于循环问题。
x = x % k
x = (x+k) % k

  • 代码实现
typedef struct {
    int* a;
    int k;
    int front; //队头下标
    int back;  //队尾下标
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {
    //1.malloc结构体指针
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    //2.malloc数组(大小固定且多开辟一个空间)
    obj->a = (int*)malloc(sizeof(int)*(k+1));
    obj->k = k;
    obj->front = 0;
    obj->back = 0;
    return obj;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->back == obj->front;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->back+1)%(obj->k+1) == obj->front;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
        return false;
     obj->a[obj->back] = value;
     //插入完back下标++
     obj->back++;
     //取模使back绕回头部
     obj->back %= (obj->k+1);
     return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return false;
    //删除队头，队头下标++
    obj->front++;
    //先++再取模
    obj->front %= (obj->k+1);
    
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(!myCircularQueueIsEmpty(obj))
        return obj->a[obj->front];
    else
        return -1;
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(!myCircularQueueIsEmpty(obj))
        return obj->a[(obj->back-1 + obj->k+1) % (obj->k+1)];
    else
        return -1;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

总结

本文精选了栈与队列经典OJ题，如果对你有所帮助，还望点赞收藏支持博主。
文章中有什么不对的丶可改正的丶可优化的地方，欢迎各位来评论区指点交流，博主看到后会一一回复。

如泡似影
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
万字精讲——数据结构栈与队列必会OJ练习
m0_74755811的博客
08-25 337
W...Y的主页 💕代码库分享 😊在之前的博客中，我们学习了栈与队列的基本内容，并且实现了栈与队列。今天我们进行刷题训练，走进栈与队列的世界中去感受一番！！！目录括号匹配问题 使用队列实现栈用栈实现队列设计循环队列以上是本次OJ题目分享全部内容，感谢大家观看，一键三连是对博主最大的支持！！！谢谢❤️
面试被问到栈和队列就不会了？精讲三道经典面试OJ题帮助你提升能力
openallzzz
12-02 584
栈和队列的详细讲解、三道OJ面试笔试题帮助你提升能力 LeetCode 232.用栈实现队列、LeetCode 225. 用队列实现栈、LeetCode 20. 有效的括号
【数据结构与算法】顺序表精讲
m0_65759588的博客
03-21 976
所属专栏：数据结构与算法 前期内容：1. 绪论1——抽象数据类型 2.绪论2——时间复杂度和空间复杂度 线性表的定义和特点
数据结构-二叉树系统性学习（四万字精讲拿捏）
Jason_from_China的博客
05-27 2016
树的关键点是不知道定义几个树的度1，明确知道的话我们可以写2，不知道几个树的度，顺序表来写3，右兄弟左孩子写法不管多少，我们只定义两个树的度}BTNode;这行代码使用typedef关键字定义了一个新的别名BTDataType，它是int类型的别名。这意味着在代码中，你可以使用BTDataType作为int类型数据的一个更有意义的别名。这行代码开始定义一个名为的新结构体类型。是结构体的名称，它将用于表示二叉树中的节点。这个大括号内的代码定义了定义了一个名为_data。
数据结构二叉树详解(C语言)
Raikkonen_love的博客
12-15 1414
树，大堆小堆，堆排序，Topk问题，二叉树，二叉树遍历，二叉树常见问题
数据结构与算法(Python版) | (7) 队列、列表OJ作业
12-21
在这篇关于“数据结构与算法(Python版) | (7) 队列、列表OJ作业”的文章中，我们将关注队列这一基本数据结构以及其在解决实际问题中的应用。 首先，我们来看有序队列的问题。有序队列要求队列中的元素按照一定的...
数据结构与算法Python版第十一周OJ作业
01-20
1 找到小镇的法官（10分） 题目内容： 在一个小镇里，按从 1 到 N 标记了 N 个人。传言称，这些人中有一个是小镇上的秘密法官。 如果小镇的法官真的存在，那么： 小镇的法官不相信任何人。 每个人（除了小镇法官外）...
mooc-清华数据结构与算法(邓俊辉) OJ习题.zip
12-27
大数据算法在数据分析中发挥着重要的作用，它可以提高分析工作的效率和准确性，为决策提供有力支持。具体来说，大数据算法可以分类、聚类、预测和关联规则分析等，从而发现数据之间的规律和关联关系，挖掘出潜在的...
Java数据结构与算法，笔试题，OJ.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
算法-KMP字符串匹配
xx_xb的博客
07-23 112
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 610
AtCoder Beginner Contest 363 ABCDE
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 687
二叉搜索树向左或向右指明方向，不用遍历整个树。
2024.7.19 刷题总结
TheJustice_的博客
07-19 291
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
插入和选择排序
c23856的博客
07-20 498
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
Python鲁汶意外莱顿复杂图拓扑分解算法
跨学科知识视角展现
07-24 686
:dart:算法池化和最佳分区搜索：:pen:网格搜索 | :pen:发现算法池 | :pen:返回指定图的最佳划分 | :pen:返回指定图的最佳分区 | :dart:适应度和聚类比较功能：:pen:图的划分 | :pen:节点度 | :pen:给定算法检测到社群总数 | :pen:图密度 | :pen:社群顶点的度数之和 | :pen:解之间的预期一致 | :pen:联合熵 | :pen:平均内部度、所有可能的节点对的平均路径长度 | :pen:节点指向社群外的边平均比例 | :pen:现有边距离社群比
python实现图像缩放算法
qq_42568323的博客
07-20 374
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
【常微分方程】
qq_74285286的博客
07-24 187
常微分方程笔记
leetcode10 -- 正则表达式匹配
m0_65985318的博客
07-24 690
那么如果s的第i个字符和p的第j个字符匹配的话，即当s[i-1]=p[j-1]（字符相等）或者p[j-1]='.'（.可以替代任意单个字符）时，两个串是否匹配则取决于除末尾位之外的剩余子串是否匹配，即s的前i-1个字符与p的前j-1个字符是否匹配，也就是dp[i][j]=dp[i-1][j-1]。用dp[i][j]表示s的前i个字符（s下标为0~i-1）与p的前j个字符（p下标为0~j-1）是否匹配，即如果dp[i][j]为true，s的前i个字符与p的前j个字符匹配，反之不匹配。，请你来实现一个支持。
C语言刷题小记2
最新发布
2302_81486993的博客
07-24 471
分析：拿到这道题，大家可能会有一种思路，就是创建一个新数组，然后进行判断，判断结束后将符合条件的元素再插入到新数组，这种想法其实是正确的，但是很可惜，本题不能用这样的方法，因为题目要求不能使用额外的数组空间，这就意味着我们是不能创建新数组的，所以本题就需要采取其他做法；大家来看，这里我分装了一个函数，里面实现的就是冒泡排序的逻辑，在主函数中，我们创建了数组去存储我们输入的成绩，然后将数据交给函数进行排序，最终我们需要返回的就是最大值；反之，我们将最后一位去除掉，将其后一位作为最后一位，再次进行判断。
C++数组实现栈与队列操作详解
本资源是一份C++编程训练营中的代码片段，涉及两个数据结构实现：栈（Stack）和队列（Queue）。首先，我们来看第一个文件`stack.cpp`： 标题："训练营OJ完整版1" 描述："这是关于C++实现一个基于数组的栈（Stack）...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值