详解顺序栈

已于 2023-10-21 17:42:05 修改
阅读量254 收藏
点赞数
文章标签： 数据结构
于 2023-10-21 17:41:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61704320/article/details/133963942
版权

顺序栈的定义以及特点

定义：

顺序栈（Sequential Stack）是一种基于数组实现的栈结构。栈是一种后进先出（LIFO）的数据结构，只能在栈顶进行插入和删除操作。顺序栈的定义如下：

  1. 数据结构：顺序栈由一个固定大小的数组和一个指向栈顶的指针组成。

  2. 操作：

    • 初始化：创建一个空栈，将栈顶指针指向-1。
    • 入栈（Push）：将元素压入栈顶，栈顶指针加1。
    • 出栈（Pop）：将栈顶元素弹出，栈顶指针减1。
    • 获取栈顶元素（Top）：返回栈顶元素的值，但不删除。
    • 判空（IsEmpty）：判断栈是否为空，即栈顶指针是否为-1。
    • 判满（IsFull）：判断栈是否已满，即栈顶指针是否达到数组的最大索引。

特点：

顺序栈的特点如下：

  1. 存储效率高：顺序栈使用数组来存储数据，因此存储效率高，不需要额外的指针域。

  2. 访问速度快：由于栈的特性，只能在栈顶进行插入和删除操作，因此访问速度快。

  3. 需要预先分配固定大小的内存空间：顺序栈需要预先分配一定大小的数组来存储数据，因此需要提前确定栈的最大容量。

  4. 容量固定：由于数组大小是固定的，顺序栈的容量是固定的，无法动态扩展。

  5. 可能存在溢出问题：当栈满时，再进行入栈操作会导致栈溢出。

总之，顺序栈是一种简单、高效的栈实现方式，适用于已知大小的栈场景。但需要注意容量的限制和溢出问题。

顺序栈的基本运算

包括初始化、入栈、出栈、获取栈顶元素、判空和判满。下面是对每个运算的详细描述：

  1. 初始化（Init）：创建一个空栈，将栈顶指针指向-1。

  2. 入栈（Push）：将元素压入栈顶，栈顶指针加1。

    • 首先判断栈是否已满（IsFull）。
    • 如果栈未满，则将元素放入栈顶位置（栈顶指针加1），并将元素存入数组中。

  3. 出栈（Pop）：将栈顶元素弹出，栈顶指针减1。

    • 首先判断栈是否为空（IsEmpty）。
    • 如果栈非空，则将栈顶元素取出并返回（栈顶指针减1）。

  4. 获取栈顶元素（Top）：返回栈顶元素的值，但不删除。

    • 首先判断栈是否为空（IsEmpty）。
    • 如果栈非空，则返回栈顶位置的元素值。

  5. 判空（IsEmpty）：判断栈是否为空，即栈顶指针是否为-1。

    • 如果栈顶指针为-1，则表示栈为空，返回真（True）。
    • 否则，栈非空，返回假（False）。

  6. 判满（IsFull）：判断栈是否已满，即栈顶指针是否达到数组的最大索引。

    • 如果栈顶指针等于数组的最大索引，则表示栈已满，返回真（True）。
    • 否则，栈未满，返回假（False）。

以上是顺序栈的基本运算，它们共同构成了对栈的常用操作。通过这些运算，可以实现栈的基本功能，如入栈、出栈、获取栈顶元素等。需要注意的是，在进行入栈和出栈操作时，需要先判断栈是否已满或为空，以避免溢出或下溢的问题。

顺序栈的实现

初始化栈

/* 1. 初始化 */
int init(SeqStack *S, int MaxSize)
{
	/*申请内存空间*/
	S->data = (DataType*)malloc(sizeof(DataType)*MaxSize);
 
	if(!S->data)
	{
		printf("内存申请错误，初始化失败！[10001]\n");
		return 10001;
	}
	S->maxsize = MaxSize;
	S->top = -1;
	return 0;
}

入栈

/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x)
{
	/*是否满？*/
	if(full(S))
	{
		printf("栈已满!10002\n");
		return 10002;
	}
 
	S->top++;			/*移动指针*/
	S->data[S->top] = x;/*放入数据*/
	return 0; /*OK*/
}

出栈

/* 3. 出栈 */
int pop(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空!10003\n");
		return 10003;
	}
 
	*x = S->data[S->top];	/*栈顶元素赋值给x*/
	S->top--;				/*移动栈顶指针*/	
 
	return 0;
}

获取栈顶元素

/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空!10003\n");
		return 10003;
	}
 
	*x = S->data[S->top];	/*栈顶元素赋值给x*/
 
	return 0;
}

判空以及判满

/* 5. 栈为空？*/
int empty(SeqStack *S)
{
	return (S->top == -1)?1:0;
}
 
/* 6. 栈满？*/
int full(SeqStack *S)
{
	return (S->top == S->maxsize - 1)?1:0;
}

销毁

/* 7. 销毁*/
int destroy(SeqStack *S)
{
	free(S->data);
	return 0;
}

顺序栈的应用部分

/*十进制转换为二进制*/
int d_to_b(int d)
{
	SeqStack S;
	int b;
 
	/*初始化栈*/
	init(&S,32);
 
	/*d不为0，余数进栈*/
	while(d)
	{
		push(&S, d % 2);
		d /= 2;
	}
	
	/*依次出栈*/
	while(!empty(&S))
	{
		pop(&S,&b);
		printf("%d", b);
	}
 
	/*销毁栈*/
	destroy(&S);
}
 
 
/*后缀表达式计算*/
int expression()
{
	SeqStack S;
	int i;
	int op1, op2;	
	int x;
 
	char exp[20]; /*后缀表达式*/
 
	init(&S, 10);
 
	printf("请输入一个后缀表达式(eg. 56+):");
	scanf("%s", exp);
	for(i=0;i<strlen(exp);i++)
	{
		switch(exp[i])
		{
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			/*入栈*/
			push(&S, exp[i]-48);
			printf("%c\n",exp[i]);
			break;
		case '+':
			/*出2个*/
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 + op2;
			push(&S, x);
			break;
 
		case '*':
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 * op2;
			push(&S, x);
			break;
		case '-':
			pop(&S, &op1);
			pop(&S, &op2);
			x =  op2- op1;
			push(&S, x);
			break;
		case '/':
			pop(&S, &op1);
			pop(&S, &op2);
			x =  op2/op1;
			push(&S, x);
			break;	
		}
	}
	pop(&S, &x);
	printf("计算结果为：%s = %d\n", exp, x);
	destroy(&S);
}

运行截图

完整Demo

main.c部分

#include <stdio.h>
#include <string.h>
#include "seqstack.c"
#include "welcome.h"


int main(int argc, char* argv[])
{
	SeqStack S;
	DataType x;
	int maxsize;
	char yn;
	int i,m,n,cmd,d;
;
	for(i=0;i<strlen(welcome);i++)
	{
		printf("%c",welcome[i]);
		for(m=0;m<1000;m++)
			for(n=0;n<1000;n++)
			{
				;
			}
	}
	
		printf("---------顺序栈演示程序-----------\n");
	do
	{
		printf(" 1. 初始化\n");
		printf(" 2. 入栈\n");
		printf(" 3. 出栈\n");
		printf(" 4. 查找栈顶元素\n");
		printf(" 5. 判断栈为是否空\n");
		printf(" 6. 判断栈为是否满\n"); 
		printf(" 7. 销毁栈\n"); 
		printf(" 8. 栈的应用\n");
		printf(" 9. 帮助\n");
		printf("请选择(0~9,0退出):");
		scanf("%d", &cmd);
		switch(cmd)
		{
		case 1:
			printf("请输入栈的最大存储空间(MaxSize):");
			scanf("%d", &maxsize);
			if(!init(&S, maxsize))
			{
				printf("栈已初始化！\n");
			}
			break;
		case 2:
			printf("请输入入栈元素:x=");
			scanf("%d", &x);
			if(!push(&S, x))
			{
				printf("元素【%d】已入栈!\n", x);
 
			}
			break;
		case 3:
			printf("确定要出栈（出栈后数据不可恢复,y|n,n)?");
			fflush(stdin);
			scanf("%c", &yn);
			if(yn == 'y' || yn == 'Y')
			{
				if(!pop(&S, &x))
				{
					printf("栈顶元素【%d】已出栈!\n", x);
				}
			}
 
			break;
		case 4:
			if(!get_top(&S,&x)){
				printf("查找到栈顶元素[%d]\n",x); 
			}
			break; 
		case 5:
			if(empty(&S)){
				printf("栈为空！\n"); 
			}else{
				printf("栈内存在元素\n"); 
			}
			break;
		case 6:
			if(full(&S)){
				printf("栈满！\n"); 
			}else{
				printf("栈未满\n"); 
			}
			break;
		case 7:
			destroy(&S);
			printf("栈已销毁\n"); 	
			break;
		case 8:
			do
			{
				printf("----------8.栈的应用------------\n");
				printf(" 1. 十进制转换为二进制\n");
				printf(" 2. 后缀表达式计算\n");			
				printf(" 0. 返回\n");
				printf("请选择：");
				scanf("%d", &cmd);
 
				if(cmd == 1)
				{
					printf("请输入一个十进制数：");
					scanf("%d", &d);
					printf("二进制为：");
					d_to_b(d);
					printf("\n");
				}
 
				if(cmd == 2)
				{
					expression();
				}
			}while(cmd!=0);
			cmd = -1;
			break;
		case 9:
			printf(" 本程序为栈的演示程序，由陈祖昊设计开发，程序完成了栈的基本功能！\n");		
		default:
			printf("输入选项不存在\n"); 		
		}
 
	}while(cmd!=0);
 
	return 0;
}
/*十进制转换为二进制*/
int d_to_b(int d)
{
	SeqStack S;
	int b;
 
	/*初始化栈*/
	init(&S,32);
 
	/*d不为0，余数进栈*/
	while(d)
	{
		push(&S, d % 2);
		d /= 2;
	}
	
	/*依次出栈*/
	while(!empty(&S))
	{
		pop(&S,&b);
		printf("%d", b);
	}
 
	/*销毁栈*/
	destroy(&S);
}
 
 
/*后缀表达式计算*/
int expression()
{
	SeqStack S;
	int i;
	int op1, op2;	
	int x;
 
	char exp[20]; /*后缀表达式*/
 
	init(&S, 10);
 
	printf("请输入一个后缀表达式(eg. 56+):");
	scanf("%s", exp);
	for(i=0;i<strlen(exp);i++)
	{
		switch(exp[i])
		{
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			/*入栈*/
			push(&S, exp[i]-48);
			printf("%c\n",exp[i]);
			break;
		case '+':
			/*出2个*/
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 + op2;
			push(&S, x);
			break;
 
		case '*':
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 * op2;
			push(&S, x);
			break;
		case '-':
			pop(&S, &op1);
			pop(&S, &op2);
			x =  op2- op1;
			push(&S, x);
			break;
		case '/':
			pop(&S, &op1);
			pop(&S, &op2);
			x =  op2/op1;
			push(&S, x);
			break;	
		}
	}
	pop(&S, &x);
	printf("计算结果为：%s = %d\n", exp, x);
	destroy(&S);
}

seqstack.c部分

#include "seqstack.h"
 
 
/* 1. 初始化 */
int init(SeqStack *S, int MaxSize)
{
	/*申请内存空间*/
	S->data = (DataType*)malloc(sizeof(DataType)*MaxSize);
 
	if(!S->data)
	{
		printf("内存申请错误，初始化失败！[10001]\n");
		return 10001;
	}
	S->maxsize = MaxSize;
	S->top = -1;
	return 0;
}
 
 
/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x)
{
	/*是否满？*/
	if(full(S))
	{
		printf("栈已满!10002\n");
		return 10002;
	}
 
	S->top++;			/*移动指针*/
	S->data[S->top] = x;/*放入数据*/
	return 0; /*OK*/
}
 
/* 3. 出栈 */
int pop(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空!10003\n");
		return 10003;
	}
 
	*x = S->data[S->top];	/*栈顶元素赋值给x*/
	S->top--;				/*移动栈顶指针*/	
 
	return 0;
}
 
/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空!10003\n");
		return 10003;
	}
 
	*x = S->data[S->top];	/*栈顶元素赋值给x*/
 
	return 0;
}
 
/* 5. 栈为空？*/
int empty(SeqStack *S)
{
	return (S->top == -1)?1:0;
}
 
/* 6. 栈满？*/
int full(SeqStack *S)
{
	return (S->top == S->maxsize - 1)?1:0;
}
 
 
/* 7. 销毁*/
int destroy(SeqStack *S)
{
	free(S->data);
	return 0;
}

seqstack.h部分

typedef int DataType;
 
 
typedef struct
{
	DataType *data; /* 堆空间 */
	int maxsize;
	int top;		/* 栈顶指针 */
}SeqStack;
 
 
/* 1. 初始化 */
int init(SeqStack *S, int MaxSize);
 
/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x);
 
/* 3. 出栈 */
int pop(SeqStack *S, DataType *x);
 
/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x);
 
/* 5. 栈为空？*/
int empty(SeqStack *S);
 
/* 6. 栈满？*/
int full(SeqStack *S);
 
/* 7. 销毁*/
int destroy(SeqStack *S);

welcome.h部分

char welcome[] = "\n\
                               ............\n\                     
                            ................\n\                   
                           ..................\n\                  
                          ....................\n\                 
                          ....................\n\                 
                           ..................\n\                  
                       ....\ ............../\n\                   
   ...........      .........................\n\                  
 ..............\  /......../######\....../###\.\n\                
................v.........##########\...#######\n\               
..........................|######/..\##.|####/.\#|       ....\n\  
..................#####\.,|######....##.|####...#|     .......\n\ 
................|########.|######....##.|####...#|     .......\n\ 
...............#########_|######\../##.|####\./#|   /##\....\n\   
 ..............###############################nn\/#######^\n\     
   \........./ \########~##############nnnnn.###########/\n\      
                ########|##########nnnnn.##############/\n\       
                 #######| \###########################/\n\        
                  \###.##\    \######################\n\          
                    \##.##\   ___   \#############/\n\            
                       \.##\/.../..\         /##/\n\              
                          \##\/..../     /####/\n\                
                             \#############/\n\
                   Welcome to the mouse program\n\n";

顺序栈学习小结

学习顺序栈是学习数据结构中的重要一步。顺序栈是一种简单、高效的栈实现方式，适用于已知大小的栈场景。学习顺序栈可以帮助我们理解栈的基本概念和操作，并能够灵活运用栈来解决实际问题。

在学习顺序栈时，我们需要掌握以下几个关键点：

  1. 栈的特点：顺序栈具有后进先出（LIFO）的特点，只能在栈顶进行插入和删除操作。

  2. 栈的基本运算：顺序栈的基本运算包括初始化、入栈、出栈、获取栈顶元素、判空和判满等操作。

  3. 存储结构：顺序栈使用数组来存储数据，因此存储效率高，不需要额外的指针域。

  4. 容量限制和溢出问题：顺序栈需要预先分配一定大小的数组来存储数据，因此容量是固定的。当栈满时，再进行入栈操作会导致栈溢出。

  5. 应用场景：顺序栈适用于已知大小的栈场景，如表达式求值、括号匹配、逆波兰表达式等问题。

通过学习顺序栈，我们能够加深对栈的理解，并能够将栈的概念和操作应用到实际问题中。同时，顺序栈也是其他栈的实现方式的基础，对于后续学习其他栈的实现方式也具有重要的参考价值。

参考文献

【1】李刚 刘万辉 “数据结构”（c语言）
【2】百度百科（百度文库）查询
小鼠Xs
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
栈的四则运算实现及详解
05-15
c语言数据结构栈的四则运算（带括号）的实现，里面有解释
【数据结构】顺序栈和链栈的基本操作（定义，初始化， 入栈，出栈，取栈顶元素，遍历，置空）
小吉妙妙屋
04-12 1万+
详细讲解顺序栈和链栈的初始化，入栈，出栈，取栈顶元素，遍历，置空等操作
顺序栈的初始化、构建、入栈，出栈和取栈顶元素
b312738566的博客
12-02 7205
顺序栈的初始化、构建、入栈，出栈和取栈顶元素
顺序存储栈（进栈，出栈，获取栈顶元素）
qq_35963993的博客
05-09 3237
顺序存储栈（进栈，出栈，获取栈顶元素）栈的特点（LIFO）栈的基本操作代码实现测试结果 栈的特点（LIFO） ① 操作受限，只允许在一端进行插入，删除操作的线性表。 ② （LIFO）后进先出 栈的基本操作 //初始化空栈 int initStack(SqStack &sqStack); //判断栈是否为空 bool stackIsEmpty(SqStack sqStack); //进栈操作 bool push(SqStack &sqStack,int value); //出栈操作 bool
【数据结构】线性表（六）堆栈：顺序栈及其基本操作（初始化、判空、判满、入栈、出栈、存取栈顶元素、清空栈）
CSDN2023博客之星Top22 人工智能领域赛道Top2 大三赛道Top2 码龄2-3年赛道Top3
10-20 2314
本文介绍了受限的线性表——堆栈，主要包括顺序栈及其基本操作：初始化、判空、判满、入栈、出栈、存取栈顶元素、清空栈等
各种数据结构空，满条件判断
张小白的博客
10-14 8917
一、线性表 由于链式存储是随意乱放，随意申请的存储结构，因此单链表，循环链表，双向链表皆不存在满的情况。 1、单链表 （不带头结点）空：head==NULL (带头结点）空：head->next==NULL 2、循环链表 空：head->next==head 3、双向链表 空：p->prior==p p->next==p 二、栈与队列 ...
数据结构 栈的操作实例详解
08-30
主要介绍了数据结构 顺序栈的定义、初始化、空栈判断、入栈、出栈操作的相关资料,需要的朋友可以参考下
栈的原理详解及其python实现
01-20
文章目录一、原理介绍1、基本介绍及特点二、python实现（一）、顺序栈的实现1、Python实现顺序栈2、代码测试（二）、链栈1、Python实现链栈2、测试三、注意事项（持续补充中…） 一、原理介绍 1、基本介绍及特点 栈...
javascript编程实现栈的方法详解【经典数据结构】
12-11
这里讲一下顺序栈，设置指针top指示栈顶元素在顺序栈中的位置。通常的做法就是以top=0表示空栈。base为栈底指针，top为栈顶指针。 如果base为null，则表示栈结构不存在，如果top=base则表示空栈。每当插入一个新的...
栈的四种情况
fade12345678的博客
03-19 3500
栈的四种情况 **满栈：**sp指针指向有内容的地址。因此，进栈是先移动指针再存；出栈是先出数据再移动指针 **空栈：**sp指针指向没有内容的地址。因此，进栈是先存再移动指针；出栈是先移动指针再出数据 **减栈：**sp指针向地址减小的方向移动。因此，进栈指针向下移动；出栈是指针向上移动 **增栈：**sp指针向地址增加的方向移动。因此，进栈指针向上移动；出栈是指针向下移动 **总结：**根据上面的栈的概念，可以组成四种栈的情况 满减栈：sp指针一开始指向有内容的地址，进栈先向下移动指针后再将内容存进
顺序栈，压栈、弹栈、获得栈顶元素、统计栈中元素个数、打印栈中元素
05-26
顺序栈，利用一组地址连续的存数单元依次存放自栈底到栈顶的数据元素，同时附设指针top指示栈顶元素在顺序栈中的位置，压栈、弹栈、获得栈顶元素、统计栈中元素个数、打印栈中元素
顺序栈和链栈操作
12-16
栈的操作,顺序栈和链栈的操作.数据结构基础.
顺序栈的建栈，入栈，出栈，取栈顶元素功能实现
naozibuok的博客
04-19 2206
顺序栈是一种线性数据结构，它具有后进先出(LIFO)的特点。在顺序栈中，所有元素存储在一个连续的内存空间中，并且每个元素只能通过栈顶进行插入和删除操作。顺序栈通常使用数组实现，栈顶指针指向最后一个入栈的元素。可以为羽毛球桶或者乒乓球桶，先放入的羽毛球最后才能拿出来，最后放入的羽毛球最先拿出来，这就是先进后出，后进先出的特点。
【C++】【数据结构】顺序栈的基本操作（初始化、入栈、出栈、取栈顶元素、遍历输出栈）的算法实现附全代码
是小雷同学的博客
04-14 1万+
使用c++完成数据结构顺序栈的基本操作，包括（初始化、入栈、出栈、取栈顶元素、遍历输出栈等），可直接编译运行。
判断顺序栈栈满的两种方式
一个搬运知识的笨小孩
01-05 3798
判断顺序栈栈满的两种方式
【数据结构】顺序栈的基本操作：出栈、入栈、取栈顶元素、输出所有栈中元素、括号匹配题目
2301_76172693的博客
10-19 1万+
栈是限定仅在表位进行插入或删除操作的线性表。栈的表尾称为栈顶，表头称为栈底。不含元素的栈称为空栈。左图为栈的示意图，右图为用铁路调度表示栈。如下是入栈至栈满再进行出栈的过程示意图。值得注意的是，栈满后，top指针指向的不是顶端元素，而是顶端的下一个位置。
栈和队列的表示及实现
1+1=王的博客
11-30 734
栈和队列栈的相关概念顺序栈的表示及实现栈的抽象数据类型的类型定义顺序栈的表示顺序表的基本操作顺序栈的初始化判断栈是否为空顺序栈的入栈顺序栈的出栈链栈的表示链栈的入栈链栈的出栈队列的基本表示及操作顺序队列循环队列的初始化求循环队列的长度循环队列的入队循环队列的出队链队列链队列的类型定义链队列初始化链队列入队链队列出队 栈的相关概念 栈（stack）是一个特殊的线性表，是限定在仅在一端进行插入和删除...
数据结构：栈(Stack)的各种操作（入栈，出栈，判断栈非空，判断栈已满，附源码）
最新发布
luming的博客
12-12 6052
栈是一种先进后出（LIFO）的数据结构，在其中元素的的添加（称为“入栈”）和删除（称为“出栈”）仅在栈的顶部进行。因此，最后一个插入到栈中的元素是第一个从栈中删除的元素。 它通常有两个主要操作： 1. push：在栈的顶部插入一个元素。 2. pop：从栈的顶部移除一个元素。 除此之外，也可以进行一些其他的操作，例如查询栈顶元素、获取栈的大小、判断栈是否为空等。栈可以用于很多应用，例如表达式求值、函数调用等。
获取顺序栈的栈顶元素
热门推荐
Caelus‘s Blobs
01-02 1万+
转至：http://www.nowamagic.net/librarys/veda/detail/2276 获取顺序栈的栈顶元素 GetTop (S,*e)：若栈存在且非空，用e返回S的栈顶元素。参考之前线性表的话，就是设一个存储栈顶的变量 e，然后通过地址传递，用 *e 来保存指针为 top 的数组元素。 函数的设计如下：/* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERR
c++ linked stack详解
03-28
Linked stack是一种基于链表实现的栈数据结构，它和顺序栈不同，顺序栈是基于数组实现的，Linked stack是基于链表实现的。这也是它和顺序栈的最大区别。 Linked stack的实现主要依靠链表的基本操作，包括插入、删除...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值