栈与队列基本操作及其应用

最新推荐文章于 2021-12-10 16:29:58 发布
最新推荐文章于 2021-12-10 16:29:58 发布
阅读量1.1k 收藏 10
点赞数 2
分类专栏： # 数据结构与算法 文章标签： 栈 队列 括号匹配 银行窗口模拟
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46672746/article/details/118096325
版权

文章目录

一、栈

栈的实现

顺序栈
#include <iostream>
using namespace std;

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1 //不可执行
#define OVERFLOW -2

#define STACK_INIT_SIZE 100 //存储空间初始分配量
#define STACKINCREMENT 10 //存储空间分配增量

typedef int SElemType;
typedef int Status;

//存储结构
typedef struct {
    SElemType* base; //栈构造之前和销毁之后，值都为NULL
    SElemType* top; //栈顶指针
    int stacksize; //当前已分配的存储空间，以元素为单位
}SqStack;

/*初始化*/
Status InitStack(SqStack& S) {
    S.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));
    if (!S.base) //存储分配失败
        exit(OVERFLOW);
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    return OK;

}
/*返回栈顶元素
用e返回栈顶元素，返回OK；若为空，返回ERROR*/
Status GetTop(SqStack S, SElemType& e) {
    if (S.top == S.base)
        return ERROR;
    return OK;
}
/*插入*/
Status Push(SqStack& S, SElemType e) {
    //e 新的栈顶元素
    if (S.top - S.base >= S.stacksize) {
        S.base = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));
        if (!S.base)
            exit(OVERFLOW);
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT;
    }
    *S.top++ = e;
    return OK;
}
/*删除栈顶元素并返回其值*/
Status Pop(SqStack& S, SElemType& e) {
    if (S.top == S.base)
        return ERROR;
    e = *--S.top;
    return OK;
}

/*判断栈是否为空*/
int StackEmpty(SqStack S)
{
    if (S.base == S.top)
        return 1;
    else
        return 0;
}


int main()
{
    SqStack S;
    InitStack(S);
    int n;
    cout << "请输入栈的长度：";
    cin >> n;
    int e1;
    for (int i = 0; i < n; i++) {
        cout << "请输入栈中第" << i + 1 << "个元素的值：";
        cin >> e1;
        Push(S, e1);
    }
    cout << "出栈：";
    int e;
    while (!StackEmpty(S))
    {
        Pop(S, e);
        cout << e << " ";

    }

    return 0;
}

栈的应用

1.数制转换(十进制转换为R进制)

将十进制数N转换为R进制数

#include <iostream>
using namespace std;

#define OK 1
#define ERROR 0
#define INFEASIBLE -1 //不可执行
#define OVERFLOW -2

#define STACK_INIT_SIZE 100 //存储空间初始分配量
#define STACKINCREMENT 10 //存储空间分配增量

typedef int SElemType;
typedef int Status;

//存储结构
typedef struct {
    SElemType* base; //栈构造之前和销毁之后，值都为NULL
    SElemType* top; //栈顶指针
    int stacksize; //当前已分配的存储空间，以元素为单位
}SqStack;

/*初始化*/
Status InitStack(SqStack& S) {
    S.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));
    if (!S.base) //存储分配失败
        exit(OVERFLOW);
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    return OK;

}

/*插入*/
Status Push(SqStack& S, SElemType e) {
    //e 新的栈顶元素
    if (S.top - S.base >= S.stacksize) {
        S.base = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));
        if (!S.base)
            exit(OVERFLOW);
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT;
    }
    *S.top++ = e;
    return OK;
}
/*删除并输出*/
Status Pop(SqStack& S, SElemType& e) {
    if (S.top == S.base)
        return ERROR;
    e = *--S.top;
    return OK;
}
/*判断是否为空 为空则返回TRUE*/
bool Stackmpty(SqStack S) {
    if (S.top == S.base) {
        return true;
    }
    else {
        return false;
    }
}
/*十进制转换为R进制*/
void conversion() {
    SqStack S;
    InitStack(S);
    int e;
    int N;
    cin >> N;
    int M = N;
    int R;
    cin >> R;
    
    while (M)
    {
        Push(S, M % R);
        M = M / R;
    }
    while (!Stackmpty(S))
    {
        Pop(S, e);
        if (e >= 0 && e <= 9) {
            cout << e;
        }
        else {
            cout << char('a' + e - 10);
        }
       
    }
 
}

int main()
{
    
    conversion();

    return 0;
}
2.括号匹配的检验
#include <iostream>
using namespace std;

#define OK 1
#define ERROR 0
#define OVERFLOW -2

#define STACK_INIT_SIZE 100 //存储空间初始分配量
#define STACKINCREMENT 10 //存储空间分配增量

typedef int SElemType;
typedef int Status;

struct SqStack {
    int* base; //栈底
    int* top;  //栈顶
    int stacksize;   //栈当前的存储空间
};
/*初始化*/
Status InitStack(SqStack& S) {
    S.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));
    if (!S.base) //存储分配失败
        exit(OVERFLOW);
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    return OK;

}
/*插入*/
Status Push(SqStack& S, SElemType e) {
    //e 新的栈顶元素
    if (S.top - S.base >= S.stacksize) {
        S.base = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));
        if (!S.base)
            exit(OVERFLOW);
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT;
    }
    *S.top++ = e;
    return OK;
}
/*删除*/
Status Pop(SqStack& S, SElemType& e) {
    if (S.top == S.base)
        return ERROR;
    e = *--S.top;
    return OK;
}
int StackEmpty(SqStack S)
{
    if (S.base == S.top)
        return 1;
    else
        return 0;
}
/*括号匹配的检验*/
void Parentheses_match()
{
    SqStack s;//初始化空栈
    InitStack(s);
    char ch[100], * p; int e;
    p = ch;
    cout << "输一个含义有()[]{}的括号表达式:\n";
    // gets(ch);
    cin >> ch;
    while (*p)
    {
        switch (*p)
        {
        case '{':
        case '[':
        case '(': Push(s, *p++); break;//只要是左括号就入栈
        case '}':
        case ']':
        case ')':Pop(s, e);
            if ((e == '{' && *p == '}') || (e == '[' && *p == ']') || (e == '(' && *p == ')'))
                p++;
            else
            {
                cout << "括号不匹配!"; exit(OVERFLOW);
            }
            break;
        default:p++;//其他字符就后移
        }
    }
    if (StackEmpty(s))
        cout << "括号匹配成功";
    else
        cout << "缺少右括号！";
    cout << endl;

}

int main() {
    Parentheses_match();

    return 0;
}



/*括号匹配的检验*/
void Parentheses_match(SqStack s,char* ch)
{
    int e;
    char* p;
    p = ch;
    while (*p)
    {
        switch (*p)
        {
        case '{':
        case '[':
        case '(': Push(s, *p++); break;//只要是左括号就入栈
        case '}':
        case ']':
        case ')':Pop(s, e);
            if ((e == '{' && *p == '}') || (e == '[' && *p == ']') || (e == '(' && *p == ')'))
                p++;
            else
            {
                cout << "括号不匹配!"; exit(OVERFLOW);
            }
            break;
        default:p++;//其他字符就后移
        }
    }
    if (StackEmpty(s))
        cout << "括号匹配成功";
    else
        cout << "缺少右括号！";
    cout << endl;

}

int main() {
    SqStack s;//初始化空栈
    InitStack(s);
    char ch[100];
    
    cout << "输一个含义有()[]{}的括号表达式:\n";
    // gets(ch);
    cin >> ch;
    Parentheses_match(s,ch);

    return 0;
}

二、队列

队列的实现

1.队列的链式表示和实现
#include <iostream>
using namespace std;

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1 //不可执行
#define OVERFLOW -2

#define STACK_INIT_SIZE 100 //存储空间初始分配量
#define STACKINCREMENT 10 //存储空间分配增量

typedef int QElemType;
typedef int Status;

/*--------单链队列-队列的链式存储结构--------*/
/*线性表的单链表的存储结构*/
typedef struct QNode {
	QElemType data;
	struct QNode* next;
}QNode,*QueuePtr;
typedef struct {
	QueuePtr front; //队头指针
	QueuePtr rear; //队尾指针
}LinkQueue;

Status InitQueue(LinkQueue& Q) {
	Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
	if (!Q.front)
		exit(OVERFLOW);
	Q.front->next = NULL;
	return OK;
}
Status DestoryQueue(LinkQueue& Q) {
	while (Q.front)
	{
		Q.rear = Q.front->next;
		free(Q.front);
		Q.front = Q.rear;
	}
	return OK;
}
/*插入元素e为Q的新的队尾元素*/
Status EnQueue(LinkQueue& Q, QElemType e) {
	QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
	if (!p)
		exit(OVERFLOW);
	p->data = e;
	p->next = NULL;
	Q.rear->next = p;
	Q.rear = p;
	return OK;
}
/*若队列不为空则删除Q的队头元素，用e返回其值，并返回ok；否则返回ERROR*/
Status DeQueue(LinkQueue& Q, QElemType& e) {
	if (Q.front == Q.rear)
		return ERROR;
	QueuePtr p = Q.front->next;
	e = p->data;
	Q.front->next = p->next;
	if (Q.rear == p)
		Q.rear = Q.front;
	free(p);
	return OK;
}
/*判断队列是否为空*/
Status QueueEmpty(LinkQueue Q) {
	if (Q.front == Q.rear)
		return TRUE;
	else
		return FALSE;
}

int main() {
	LinkQueue q;
	InitQueue(q);
	int n;	
	cout << "请输入队列的长度：";
	cin >> n;
	int e1;
	for (int i = 0; i < n; i++) {
		cout << "请输入队列中第" << i+1 << "个元素的值：";		
		cin >> e1;
		EnQueue(q, e1);
	}
	cout << "出队：";
	int e;
	while (!QueueEmpty(q))
	{
		DeQueue(q, e);
		cout << e << " ";
	}
	
	return 0;
}
2.循环队列-队列的顺序表示和实现
#include <iostream>
using namespace std;

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1 //不可执行
#define OVERFLOW -2

#define STACK_INIT_SIZE 100 //存储空间初始分配量
#define STACKINCREMENT 10 //存储空间分配增量

typedef int QElemType;
typedef int Status;

#define MAXQSIZE 100 //最大队列长度

/*--------单链队列-队列的顺序存储结构--------*/
/*线性表的单链表的存储结构*/
typedef struct QNode {
	QElemType* base;
	int front;
	int rear;
}SqList;


Status InitQueue(SqList& Q) {
	Q.base = (QElemType*)malloc(MAXQSIZE * sizeof(QElemType));
	if (!Q.base)
		exit(OVERFLOW);
	Q.front = Q.rear = 0;
	return OK;
}

int QueueLength(SqList Q) {
	return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
}

/*插入元素e为Q的新的队尾元素*/
Status EnQueue(SqList& Q, QElemType e) {
	if ((Q.rear + 1) % MAXQSIZE == Q.front)
		return ERROR;
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear + 1) % MAXQSIZE;
	return OK;
}

/*若队列不为空则删除Q的队头元素，用e返回其值，并返回ok；否则返回ERROR*/
Status DeQueue(SqList& Q, QElemType& e) {
	if (Q.front == Q.rear)
		return ERROR;
	e = Q.base[Q.front];
	Q.front = (Q.front + 1) % MAXQSIZE;
	return OK;
}
/*判断队列是否为空*/
Status QueueEmpty(SqList Q) {
	if (Q.front == Q.rear)
		return TRUE;
	else
		return FALSE;
}

int main() {
	SqList q;
	InitQueue(q);
	int n;
	cout << "请输入队列的长度：";
	cin >> n;
	int e1;
	for (int i = 0; i < n; i++) {
		cout << "请输入队列中第" << i + 1 << "个元素的值：";
		cin >> e1;
		EnQueue(q, e1);
	}
	int e;
	cout << "出队：";
	while (!QueueEmpty(q))
	{
		DeQueue(q, e);
		cout << e << " ";
	}
	/*while ((q.rear + 1) % MAXQSIZE != q.front)
	{
		cout << q.base[q.rear]<<" ";
		q.rear++;
	}*/

	return 0;
}

队列的应用

1.用循环队列模拟银行窗口排队

具体要求如下：

① 用整数代表排队客户的编号。

② 入队和出队的调用序列可直接写在代码中 （但要足够多以覆盖到各种情况）。

③ 每次执行完入队或出队操作后，打印队列中的全部元素。

④ 极端情况 （如满时入队、空时出队）发生时，打印提示信息。

#include <iostream>
#include <random>
using namespace std;

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1 //不可执行
#define OVERFLOW -2



typedef int QElemType;
typedef int Status;

#define MAXQSIZE 20 //最大队列长度

typedef struct QNode {
	QElemType* base;
	int front;
	int rear;
}SqList;


Status InitQueue(SqList& Q) {
	Q.base = (QElemType*)malloc(MAXQSIZE * sizeof(QElemType));
	if (!Q.base)
		exit(OVERFLOW);
	Q.front = Q.rear = 0;
	return OK;
}


/*插入元素e为Q的新的队尾元素*/
Status EnQueue(SqList& Q, QElemType e) {
	if ((Q.rear + 1) % MAXQSIZE == Q.front)
		return ERROR;
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear + 1) % MAXQSIZE;
	return OK;
}

/*若队列不为空则删除Q的队头元素，用e返回其值，并返回ok；否则返回ERROR*/
Status DeQueue(SqList& Q, QElemType& e) {
	if (Q.front == Q.rear)
		return ERROR;
	e = Q.base[Q.front];
	Q.front = (Q.front + 1) % MAXQSIZE;
	return OK;
}
/*判断队列是否为空*/
Status QueueEmpty(SqList Q) {
	if (Q.front == Q.rear)
		return TRUE;
	else
		return FALSE;
}
/*取出队头元素，不删除*/
Status GetHead(SqList Q, QElemType& e) {
	if (Q.front == Q.rear)
		return ERROR;
	e = Q.base[Q.front];
	return OK;
}
int QueueLength(SqList Q) {
	return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
}
int main() {
	SqList q;
	InitQueue(q);
	int e;
	
	int t = 0, s = 0;
	int j = -1;
	int c=1;
	int dui = 1;
	while (c)
	{
		cout << "               =================================" << endl;
		cout << "               | 1.入队                        |" << endl;
		cout << "               | 2.出队                        |" << endl;		
		cout << "               | 0.退出                        |" << endl;
		cout << "               =================================" << endl;
		cout << "请输入你的选择：" << endl;
		cin >> c;
		switch (c)
		{
		case 1:
			int a[10];
			int b[100];
			for (int i = 0; i < 10; i++) {
				a[i] = rand() % 2;
				cout << a[i] << "  ";
			}
			cout << endl;
			
			/*如果是0入队*/
			for (int i = 0; i < 10; i++) {
				t = t + 1;
				if (a[i] == 0) {
					s++;
					if (s == 1) {
						cout << "入队:";
					}
					j=j+1;
					b[j] = t;
					if (EnQueue(q, t)==ERROR) {
						dui = 0;
						cout << "满队列！！！";
					}
					
				}
			}
			if (dui) {
				for (int i = 0; i < QueueLength(q); i++) {
					cout << b[i] << " ";
				}
			}
			
			cout << endl;
			break;
		case 2:
			cout << "出队：";
			if (QueueEmpty(q)) {
				cout << "空队列!!!!";
			}
			while (!QueueEmpty(q))
			{
				DeQueue(q, e);
				cout << e << " ";
			}
			cout << endl;
			break;
		case 0:
			break;
		
		default:
			break;
		}

	}
	

	return 0;
}
十里青柚
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
栈和队列的基本操作及其应用
04-15
1、掌握栈和队列的顺序存储结构和链式存储结构，以便在实际中灵活应用。 2、掌握栈和队列的特点，即后进先出和先进先出的原则。 3、掌握栈和队列的基本运算，如：入栈与出栈，入队与出队等运算在顺序存储结构和链式存储结构上的实现。
栈和队列的基本操作和应用
LiXingyue
08-23 651
本文主要内容： 栈的基本操作及实现 队列的基本操作及实现 栈和队列的应用 1.栈：先进后出、后进先出 （1）栈顶是当前水平面的位置top （2）栈的基本操作： push：压栈，放入数据 pop：弹栈，删除此堆数据 peek：查看堆顶元素 empty：判断栈是否为空 search：查找元素 （3）实现：链表可以实现栈（头插头删），顺序表也可以实现栈（尾插、尾删）,时间复杂度均为o(1) （4）S...
栈和队列的基本操作及应用
weixin_44350170的博客
10-12 410
题目一：回文判断 [问题描述] 对于一个从键盘输入的字符串，判断其是否为回文。回文即正反序相同。如“abba”是回文，而“abab”不是回文。 [基本要求] （1）数据从键盘读入； （2）输出要判断的字符串； （3）利用栈和队列对给定的字符串判断其是否是回文，若是则输出“Yes”，否则输出“No”。 [Sample Input] 123321 12312 [Sample Output] Yes ...
栈和队列基本操作与应用
qq_59126785的博客
12-10 327
数据结构——栈和队列
栈和队列的基本操作实现及其应用实验报告
12-20
栈和队列的基本操作实验报告 一、实验目的 1、熟练掌握栈和队列的基本操作在两种存储结构上的实现。 2、会用栈和队列解决简单的实际问题。 二、实验内容 题目：试写一个算法，判断依次读入的一个以@为结束符的...
栈和队列的基本操作实现及其应用.doc
10-10
栈和队列的基本操作实现及其应用.doc
栈和队列的基本操作实现及其应用
05-14
编程模拟队列的管理，主要包括：出队列、入队、统计队列的长度、查找队列某个元素e、及输出队列中元素。
栈与队列的应用与区别
04-19
栈与队列的应用与区别
栈和队列基本操作及练习
08-05
栈和队列基本操作及练习
栈和队列的基本操作
Const帆的博客
07-24 1798
栈：头添加头删除 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct node1 { int nValue; struct node1 *pNext; }MyStack; typedef struct node2 { int nCount; MyStack *pTop; }Stack; void s_Init...
栈和队列的基本应用
CYBCLOUD的博客
08-27 2298
1 栈的基本应用 1.1括号匹配 问题: 假设表达式有三种括号：圆括号“（）”，花括号“｛｝”，方括号“［］”。它们可互相嵌套，如｛（［］）｝或｛（［］）（）［］｝均为正确格式。而｛）），｛［（）］均为不正确格式。 输入由三种括号构成的字符串，如何检测字符串里括号格式的正确性？ 算法思路： 创建一个空栈，开始顺序扫描所有字符 遇到左括号入栈 遇到右括号则弹出已入栈的栈顶左括号（若栈为空没有左括号，直接退出报错） 检查两括号是否匹配（若两括号类型不一样，直接退出报错） 若所有字符都扫描完.
2020-2021年度第二届全国大学生算法设计与编程挑战赛 （秋季赛）-正式赛-详细题解
qq_46672746的博客
11-17 2947
文章目录A小x的奇遇-adventureB数位dp-dp A小x的奇遇-adventure #include <cstdio> const int N = 1e6 + 5; int tot, p[N]; bool flg[N]; void sieve(int n){ for(int i=2; i<=n; i++){ if(!flg[i]){ p[++tot] = i; } for(int j=1; j<=tot&&i*p[j]<=
单链表--键盘输入、插入、删除、查询、输出
qq_46672746的博客
06-10 2828
通过键盘读入数据，创建一只带有头点的单链表。要求能够实现求单链表的长度，查询单链表中指定位置上的节点信息，能够进行节点的插入、删除、查询、输出操作 # include "stdio.h" # include "stdlib.h" /*构造链表节点的数据类型*/ struct Node { int data; struct Node *next; }; /*对链表进行初始化操作*/ struct Node *InitList(struct Node *L) { struct Node *head = N
LeetCode_数组_简单题
qq_46672746的博客
07-22 1573
目录26.删除排序数组中的重复项27.移除元素53.最大子序和 26.删除排序数组中的重复项 int removeDuplicates(int* nums, int numsSize){ if(numsSize==0){ return 0; } int i = 0,j; for(j=1; j<numsSize; j++){ if(nums[j]!=nums[i]){ i++; nums
设计一个应用程序（C/C++），利用多级菜单实现单链表、栈、队列、二叉树及图五种结构的基本操作及应用。
最新发布
05-30
好的，这是一个比较全面的课程设计，需要掌握许多数据结构的基本操作。以下是一个简单的实现思路，希望能够对您有所帮助。 1. 设计多级菜单 首先，需要设计一个多级菜单，用于用户选择需要进行的操作。可以采用switch-case语句实现多级菜单，每一级菜单对应一种数据结构，例如： ``` while (true) { cout << "请选择要操作的数据结构：" << endl; cout << "1. 单链表" << endl; cout << "2. 栈" << endl; cout << "3. 队列" << endl; cout << "4. 二叉树" << endl; cout << "5. 图" << endl; cout << "0. 退出" << endl; int choice; cin >> choice; switch (choice) { case 1: // 单链表操作 break; case 2: // 栈操作 break; case 3: // 队列操作 break; case 4: // 二叉树操作 break; case 5: // 图操作 break; case 0: // 退出程序 return 0; default: cout << "输入错误，请重新选择！" << endl; break; } } ``` 2. 实现单链表、栈、队列、二叉树及图的基本操作 根据菜单选择，对应实现单链表、栈、队列、二叉树及图的基本操作。以下是一些基本操作的实现思路： 单链表： 单链表的基本操作包括：创建链表、插入节点、删除节点、查找节点、遍历链表等。可以使用结构体定义链表节点，使用指针进行节点之间的连接操作。 栈： 栈的基本操作包括：入栈、出栈、判断栈是否为空、获取栈顶元素等。可以使用数组或链表实现栈。 队列： 队列的基本操作包括：入队、出队、判断队列是否为空、获取队头元素等。可以使用数组或链表实现队列。 二叉树： 二叉树的基本操作包括：创建二叉树、前序遍历、中序遍历、后序遍历、层次遍历等。可以使用结构体定义二叉树节点，使用递归或栈实现遍历。 图： 图的基本操作包括：创建图、添加顶点、添加边、删除顶点、删除边、遍历图等。可以使用邻接矩阵或邻接表实现图。 3. 实现单链表、栈、队列、二叉树及图的应用 根据具体需求，实现单链表、栈、队列、二叉树及图的应用。例如，可以使用单链表实现学生信息管理系统，使用栈实现表达式求值，使用队列实现银行排队系统，使用二叉树实现表达式求值，使用图实现地图导航等。 以上是一个简单的实现思路，具体实现过程中还需要考虑一些细节问题，例如内存泄漏、异常处理、代码优化等。希望能够对您有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值