数据结构之栈的相关实现（C语言）

最新推荐文章于 2022-04-21 21:49:45 发布
最新推荐文章于 2022-04-21 21:49:45 发布
阅读量230 收藏
点赞数
分类专栏： 数据结构 文章标签： c语言 数据结构 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44519040/article/details/119515877
版权

参考：1.网课：数据结构与算法基础（青岛大学-王卓）
2.教材：数据结构（c语言版）第二版，严蔚敏，李冬梅等著

非科班自学，如有错误望不吝赐教。

顺序栈

0.基本操作

#include <stdio.h>
#include <malloc.h>
#define Max 100
#define OVERFLOW -2
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define INFEASIBLE -1
typedef int Status;
typedef int SElemType;


//0.顺序栈的储存结构
typedef struct{
    SElemType* base;//栈底指针
    SElemType* top;//栈顶指针
    int stacksize;//栈可用的最大容量
}SqStack;



//1.顺序栈的初始化
Status InitStack(SqStack* S){
    S->base=(SElemType*)malloc(Max*sizeof(SElemType));//给栈底指针分配内存空间，栈底指针表示了一个数组
//    if(!S->base) exit(OVERFLOW);
    S->top=S->base;
    S->stacksize=Max;
    return OK;
}



//2.进栈
Status Push(SqStack* S,SElemType a){
    if(S->top-S->base==S->stacksize) return ERROR;//判断是否满栈
    *(S->top)=a;
    printf("push%d /n",*(S->top));
    S->top++;
    
}


//3.出栈
Status Pop(SqStack* S,SElemType* e){
    if(S->top==S->base) return ERROR;//判断是否空栈
    *e=*(S->top-1);printf("pop %d \n",*e);//*e是存储出栈元素的值,e是指针
    S->top--;//顺序栈中指针划过去就表示空间的销毁释放（实际上还在）
    return OK;
}




//4.打印栈（注意：不能直接用S->top,否则打印完了整个栈也没了(也不是没了，仍然可以用base[n]去访问栈里面的元素，就是S->top指针没用了)）
//先进先出
Status PrintStack(SqStack* S){    SElemType* p=S->top;
    printf("\n print the stack:");
    while(p!=S->base){
        printf("%d " ,*(p-1));
        p--;
    }
}


//简单的调试
int main(){
    int i,j;i=0;
    SElemType a;
    printf("请输入原始栈的长度：");
    scanf("%d",&j);
    SqStack S;//不能定义指针 因为定义指针不意味着定义了指针所指向的东西，所以在函数里面用到S->base都会报错
    InitStack(&S);
    while(i<j){
    printf("please input data:");
    scanf("%d",&a);
    Push(&S,a); 
    i++;
    }
    PrintStack(&S);
}

这里犯过两个错误：

  • 定义某个数据类型的时候不能只直接定义指向它的指针，定义了指针不意味着是定义了它指向的数据类型，比如我一开始初始化栈的时候是这样做的，就会报错：
    SqStack* S;
    InitStack(S);
  • 打印栈的时候，要重新定义一个指针p，来指向每次要打印的数据元素，如果用头指针S->top的话，栈打印完毕，整个栈就“空了”:
Status PrintStack(SqStack* S){    
    printf("\n print the stack:");
    while(S->top!=S->base){
        printf("%d " ,*(S->top-1));
        S->top--;
    }
}
  • 关于scanf：
    scanf()在读取数字时会跳过空格、制表符和换行符！
    scanf遇到 回车(enter)，空格，TAB 就会结束一次输入，空格不会接;
    并且， scanf在一次输入结束后，不会舍弃最后的回车符（即回车符会残留在数据缓冲区中）
    fflush(stdin)：清空缓冲区
    \qquad 查找这方面的资料是因为想实现如下的功能：每次都向栈中压入一个数据，直到连续敲两次(或更多)回车停止循环，不过最后还是没有能实现，本来打算在每个循环中加入getchar()作为判断是否跳出循环的标记，但它似乎每次都会吃掉scanf留在缓冲区的回车。
    补充资料：C语言中scanf函数输入回车符的问题;scanf语句吃掉回车或者空格问题详解;

1. 用栈判断是否是回文

Input:字符序列与之长度
Output:（Not）palindrome
想法：把字符序列的前一半入栈，然后逐一出栈，由于先进后出，所以先出来的是原字符序列更靠近中间的;字符的后一半顺序就从左到右即可。
\qquad 两部分相应比较，如果出现不等的字符对则不是回文

    //试写一个算法判定给定的字符序列是否为回文
int main(){
    SElemType a;
    SElemType e;//定义指针不意味着分配了相应的空间
    int flag=0;
    char s[30]= {0};
    int m,mm,i=0;
    printf("Please enter a string :");
    scanf("%s",&s);
    //m=con_str(s);//可以自定义一个函数计算字符串的长度
    printf("Please enter length of the string :");
    scanf("%d",&m);
    mm=(int) m/2;
    SqStack S;//不能定义指针 因为定义指针不意味着定义了指针所指向的东西，所以在函数里面用到S->base都会报错
    InitStack(&S);
    while(i<mm){//将前一半的字符压入栈中
        a=s[i];
    Push(&S,a);
    i++;
    }
    while(i>0){
        a=s[m-i];
        Pop(&S,&e);//将栈中的字符串逐一出栈，注意到先进后出，所以先出来是的更靠近中间，后半段的字符串从左往右逐次输出即可
        if(a!=e){
            flag=1;
            break;
        };
    i--;
    }
    if(flag==1){
        printf("Not palindrome");
    }
    else{
        printf("Palindrome");}
    return 0;
}

链栈

0.基本操作

#include <stdio.h>
#include <malloc.h>
#define Max 100
#define OVERFLOW -2
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define INFEASIBLE -1
typedef int Status;
typedef int SElemType;

//0.链栈的存储结构
typedef struct StackNode
{
    SElemType data;
    struct StackNode* next;
}StackNode,*LinkStack;

//1.链栈的初始化 (链栈不需要头结点,S始终为栈顶指针)
Status InitStack2(LinkStack* SS){
    *SS=NULL;
    return OK;
}

//2.链栈的入栈
Status Push2(LinkStack* SS,SElemType a){
    LinkStack p=(LinkStack)malloc(sizeof(SElemType));//申请一个结点的内存用于存放新元素
    p->data=a;
    p->next=*SS;
    *SS=p;
    printf("Push %d ",a);
    return OK;
}

//3.链栈的出栈
Status Pop2(LinkStack* SS,SElemType* e){
    if(*SS==NULL) return ERROR;
    *e=(*SS)->data;//存放出栈的元素
    LinkStack p=*SS;
    *SS=(*SS)->next;
    printf("Pop %d ",*e);
    free(p);
    return OK;
}

//4.打印链栈
Status PrintStack2(LinkStack S){    
    LinkStack p=S;//需要另外定义一个指针指向打印的结点
    printf("\n print the stack:");
    while(p!=NULL){
        printf("%d " ,(p->data));
        p=p->next;
    }
}


//简单的调试
int main(){
  int j,i=0;LinkStack S;SElemType a;
    InitStack2(&S);
    printf("请输入原始栈的的长度");
    scanf("%d",&j);
    while (i<j){
        printf("please input data:");
        scanf("%d",&a);
        Push2(&S,a); 
        i++;
    }
    PrintStack2(S);
}

注意：

  • 链栈不需要头结点,S始终为栈顶指针，指针方向指向栈底
  • 用c语言实现链栈的操作时候（初始化/入栈/出栈）需要对书上的内容稍稍修改，书本上的内容如下（书本上用的是c++的引用是没有问题的）：
//1.链栈的初始化 (链栈不需要头结点,S始终为栈顶指针)
Status InitStack2(LinkStack S){
    S=NULL;
    return OK;
}

//2.链栈的入栈
Status Push2(LinkStack S,SElemType a){
    LinkStack p=(LinkStack)malloc(sizeof(SElemType));//申请一个结点的内存用于存放新元素
    p->data=a;
    p->next=S;
    S=p;
    printf("Push %d ",a);
    return OK;
}

//3.链栈的出栈
Status Pop2(LinkStack S,SElemType* e){
    if(S==NULL) return ERROR;
    *e=S->data;//存放出栈的元素
    LinkStack p=S;
    S=S->next;
    printf("Pop %d ",*e);
    free(p);
    return OK;
}

//简单的调试
int main(){
  int j,i=0;LinkStack S;SElemType a;
    InitStack2(S);
    printf("请输入原始栈的的长度");
    scanf("%d",&j);
    while (i<j){
        printf("please input data:");
        scanf("%d",&a);
        Push2(S,a); 
        i++;
    }
    //PrintStack2(S);
}

由于自定义函数无法改变实参的内容，所以在自定义函数里面定义的那些对S的操作都是传不到主函数里的；
希望用函数修改实参可以通过传入这个实参的指针，所以定义了LinkStack* SS，它是指向LinkStack S的指针。
想知道除了定义二级指针，还有其他方法嘛？

1.计算后缀表达式

Input:后缀表达式（下面的代码暂时只能处理操作数是整数，小数需要修改占位符和定义的相关数据类型等等）
output:计算结果
idea: 定义一个栈OPTD用于存放操作数和运算结果，输入表达式
\qquad 用scanf扫描表达式，读入并处理得到第一个字符ch（具体处理方法见代码）
\qquad 若ch为操作数则压入OPTD
\qquad 若ch为操作符 ，从OPTD出栈两个数，结合这个操作符进行运算，把运算结果再压入栈中
\qquad 读入下一个字符，直到遇到回车为止
\qquad 最后将OPTD中元素出栈，即为所求结果
这里代码参考了C语言 后缀表达式;

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#define Max 100
#define OVERFLOW -2
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define INFEASIBLE -1
typedef int Status;
typedef int SElemType;


typedef struct{//顺序栈的储存结构
    SElemType* base;//栈底指针
    SElemType* top;//栈顶指针
    int stacksize;//栈可用的最大容量
}SqStack;

Status InitStack(SqStack* S){//顺序栈的初始化
    S->base=(SElemType*)malloc(Max*sizeof(SElemType));//给栈底指针分配内存空间，栈底指针表示了一个数组
//    if(!S->base) exit(OVERFLOW);
    S->top=S->base;
    S->stacksize=Max;
    return OK;
}


//进栈
Status Push(SqStack* S,SElemType a){
    if(S->top-S->base==S->stacksize) return ERROR;//判断是否满栈
    *(S->top)=a;
    printf("push%d /n",*(S->top));
    S->top++;
    
}


//出栈
Status Pop(SqStack* S,SElemType* e){
    if(S->top==S->base) return ERROR;//判断是否空栈
    *e=*(S->top-1);printf("pop %d \n",*e);//*e是存储出栈元素的值,e是指针
    S->top--;//顺序栈中指针划过去就表示空间的销毁释放（实际上还在）
    return OK;
}



//打印顺序栈（注意：不能直接用S->top,否则打印完了整个栈也没了(也不是没了，仍然可以用base[n]去访问栈里面的元素，就是S->top指针没用了)）
//先进先出
Status PrintStack(SqStack* S){    SElemType* p=S->top;
    printf("\n print the stack:");
    while(p!=S->base){
        printf("%d " ,*(p-1));
        p--;
    }
}

//链栈的存储结构
typedef struct StackNode
{
    SElemType data;
    struct StackNode* next;
}StackNode,*LinkStack;

//链栈的初始化(链栈不需要头结点,S始终为栈顶指针)
Status InitStack2(LinkStack* SS){
    *SS=NULL;
    return OK;
}

//链栈的入栈
Status Push2(LinkStack* SS,SElemType a){
    LinkStack p=(LinkStack)malloc(sizeof(SElemType));//申请一个结点的内存用于存放新元素
    p->data=a;
    p->next=*SS;
    *SS=p;
    printf("Push %d ",a);
    return OK;
}

//链栈的出栈
Status Pop2(LinkStack* SS,SElemType* e){
    if(*SS==NULL) return ERROR;
    *e=(*SS)->data;//存放出栈的元素
    LinkStack p=*SS;
    *SS=(*SS)->next;
    printf("Pop %d ",*e);
    free(p);
    return OK;
}

//打印链栈
Status PrintStack2(LinkStack S){    
    LinkStack p=S;//需要另外定义一个指针指向打印的结点
    printf("\n print the stack:");
    while(p!=NULL){
        printf("%d " ,(p->data));
        p=p->next;
    }
}

从键盘上输入一个后缀表达式，试编写算法计算表达式的值
int main(){
    LinkStack OPTD;
    InitStack2(&OPTD);//初始化栈
    char str[10];
    char data;
    SElemType store;
    int i=0;
    SElemType e1;
    SElemType e2;


    printf("请输入一串后缀表达式, 以Enter结束: \n");
    scanf("%c", &data);
    while(data != '\n'){//直到遇到回车停止扫描
 
 
        while(isdigit(data) || '.' == data){//当data是操作数时，暂时先一个一个存到数组str中，当遇到空格时，把数组转换成浮点数
            str[i++] = data;
            str[i] = '\0';
            if (i >= 10){
            printf("输入的单个数据过大\n");
            return -1;
            } 
 
        scanf("%c", &data);
        if(' ' == data){
            store = atof(str);//把str中的数字序列转化为浮点数（需要头文件#include <stdlib.h>）
            Push2(&OPTD, store);//将操作数压入栈
            i = 0;
            break;
            }
        }

        switch(data){//当data是运算符时
            case '+':
                Pop2(&OPTD, &e2);
                Pop2(&OPTD, &e1);//将OPTD最上面的两个操作数出栈
                Push2(&OPTD, e1 + e2);//将其相加再入栈
                break;
            case '-':
                Pop2(&OPTD, &e2);
                Pop2(&OPTD, &e1);//将OPTD最上面的两个操作数出栈
                Push2(&OPTD, e1 - e2);//将其相减再入栈
                break;
            case '*':
                Pop2(&OPTD, &e2);
                Pop2(&OPTD, &e1);//将OPTD最上面的两个操作数出栈
                Push2(&OPTD, e1 * e2);//将其相乘再入栈
                break;
            case '/':
                Pop2(&OPTD, &e2);
                Pop2(&OPTD, &e1);//将OPTD最上面的两个操作数出栈
 
                if(e2 == 0){
                    printf("输入错误,除数不能为0\n");
                    return -1;
                    }
                Push2(&OPTD, e1 / e2);//将其相除再入栈
                break;
        }
         scanf("%c", &data);
    }
    PrintStack2(OPTD);

}

注意：

  • scanf的扫描原理

2.判断入栈/出栈的序列是否合法

Input:1或0的序列，1表示入栈，0表示出栈
Output:true/false
idea:每次操作后记录栈中元素个数，小于0则break循环，返回false

//
#include <stdio.h>
int main(){
char seq[10];
int i=0;
int j=0;//用来记录每次操作后还有几个元素
int m=0;
int flag =0;
char data;
do{
scanf("%c",&data);
seq[m]=data;//输入10110100[enter]后m是9
m++;
}while(data!='\n');

for(i=0;i<m-1;i++){
    if(seq[i]=='1'){
        j++;
    }
    else{
        j--;
    }
    if(j<0){
        flag=1;
        break;
    }
}
if(flag==1){
    printf("false");
}
else{
    printf("true");
}

}
一只小暑
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构入门（一）栈的实现
山阴少年
12-05 512
  从这一篇文章开始，笔者将会正式进入数据结构的领域，后面也将会持续更新。   本文将会讲述一种特殊的线性表结构：栈（stack）。   栈，是限定仅在表尾进行插入或删除操作的线性表。因此，对栈来说，表尾端有其特殊含义，称为栈顶（top），相应地，表头端称为栈底（bottom）。不含任何元素的空表称为空栈。   假设栈S=(a1,a2,...,an),S=(a_{1},a_{2},...,a_{n...
自定义实现栈的功能
dichengpai8268的博客
02-18 145
栈的定义：栈是一个数据集合，我们可以吧它理解为是一个只能在一端进行插入或者删除的列表。栈的特点：先进后出 Stack() 建立一个空的栈对象 push() 吧一个元素添加到栈的最顶层 pop() 删除栈最顶层的元素，并返回这个元素 gettop() 取栈顶元素 isEmpty() 判断栈是否为空 size() 返回栈中元素的个数 peek() 返回最顶层的元素，并不删除...
数据结构与算法实验 ——（二）实验二 栈的设计、实现及应用
Xin_Qing_的博客
05-30 2404
一、实验目的、要求 1．掌握栈、队列的思想及其存储实现。 2．掌握栈、队列的常见算法的程序实现。 二、实验内容 1．采用链式存储实现栈的初始化、入栈、出栈操作。 2．采用顺序存储实现栈的初始化、入栈、出栈操作。 3．采用链式存储实现队列的初始化、入队、出队操作。 4．采用顺序存储实现循环队列的初始化、入队、出队操作。 5．在主函数中设计一个简单的菜单，分别测试上述算法。 *6．综合训练: 1)利用栈实现表达式求值算法。 2)利用栈实现迷宫求解。 三、实验说明 1．基本要求：实现算法 1、3 或算法 2、4
数据结构--算术表达式求值
hanmengyuan2001的博客
01-07 3824
一、上机实验的问题和要求： 设计一个程序，演示用算符优先法对算术表达式求值的过程。 二、程序设计的基本思想，原理和算法描述： 原理：根据算术四则运算法则按照优先级对表达式进行处理 算法描述：设置栈顶指针、栈底指针并分配相应的存储空间，再定义运算符，构造空栈并分别进行入栈出栈，根据运算符优先级对表达式进行处理，最后得到结果并输出。 三、调试和运行程序过程中产生的问题及采取的措施： 调试程序时未发现错误 四、源程序及注释 #include<stdio.h> #incl...
数据结构3——linuxC(栈和队列)
天天的博客
03-02 2754
demo1顺序栈 #include <stdio.h> #define SEQ_STACK_SIZE 10 // 顺序栈数据节点 struct seq_stack{ int data; }; // 顺序栈下标 int g_n; // 入栈(压栈) void stack_push(int new_data, struct seq_stack *s); // 出栈(弹栈) int stack_pop(int *pop_data, struct seq_stack *s); // 显示顺序.
C语言 数据结构中栈的实现代码
09-01
数据结构中的栈是一种非常基础且重要的抽象数据类型，它的特点是具有后进先出（LIFO，Last In First Out）的特性。栈的操作主要包括入栈（Push）和出栈（Pop）。在C语言中，我们可以使用两种方式来实现栈：静态栈...
数据结构-栈的C语言实现
01-20
数据结构-栈的C语言实现，随手笔记
C语言数据结构之栈简单操作
01-01
C语言数据结构之栈简单操作 实验： 编写一个程序实现顺序栈的各种基本运算，并在此基础上设计一个主程序，完成如下功能： （1）初始化顺序栈 （2）插入元素 （3）删除栈顶元素 （4）取栈顶元素 （5）遍历顺序栈 ...
数据结构-栈的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 栈的部分实现代码（栈的实现、栈的应用），详细介绍参考数据结构--栈的系列博文。链接为：https://blog.csdn.net/songshuai0223/category_9742561.html。
堆栈
qq_42711300的博客
03-25 400
自家写的栈，目前只有初始化，出栈，入栈操作，因为结构知道，栈顶元素可以自己看 一：顺序栈 #include <bits/stdc++.h> #define ref1(i,s,e,c) for(int i=s;i<e;i=i+c) #define ref2(i,s,e,c) for(int i=s;i<=e;i=i+c) #define ref3(i,e,s,c) fo...
算法---栈和队列
qq_41683305的博客
04-21 624
栈和队列1 栈栈的顺序存储栈的链式存储2 队列队列的顺序存储队列的链式存储 1 栈 参考文章： https://zhuanlan.zhihu.com/p/346164833 https://zhuanlan.zhihu.com/p/120965372#:~:text=%E6%A0%88%E6%98%AF%E4%B8%80%E7%A7%8D%20%E5%90%8E%E8%BF%9B%E5%85%88%E5%87%BA%EF%BC%88LIFO%EF%BC%89,%E7%9A%84%E6%95%B0%E6%8D
数据结构与算法——栈的运用
abcwsp的博客
12-13 474
数据结构——栈的应用 雨中漫步 下面将中序表达式转化为后缀表达式，再将后续表达式翻译运算 //求简单表达式的值 #include <stdio.h> #include <stdlib.h> #define MaxSize 100 //--------------------------------------------------------- //--运算符栈基本运算-...
链栈的C语言实现
沐尔还吃
07-12 1163
#include &lt;stdio.h&gt;#include &lt;stdlib.h&gt;#include &lt;malloc.h&gt;#define ERROR -1#define OK 1///链栈的实现：链栈是运算受限的单链表，其插入和删除只能在表头位置上进行。typedef struct Stack_Node{    int data;    struct Stack_Node...
重新学习C语言的第十一天
帅才的博客
07-14 469
结构体 ·有时需要将不同类型的数据组合成一个有机的整体，以便于引用。 #include<stdio.h> int main() { struct student { int num; char *name; char sex; float score; } boy1,boy2; boy1.num=007; boy1.name="Jame"; printf("Please input sex and score\n"); scanf("%c %f",&boy1
数据结构复习4-栈和队列
weixin_51134546的博客
06-27 488
栈和队列 3.1 栈的基本概念 （一）栈的定义 栈是一种只允许在表的一端进行插入操作和删除操作的线性表。允许操作的一端称为栈顶，栈顶元素的位置由一个称为栈顶位置的变量给出。当表中没有元素时，称之为空栈。 栈的特点： 元素间呈线性关系 插入删除在一端进行 后进先出，先进后出——LIFO（Last-In-First-Out） （二）栈的基本操作 其操作仅仅是一般线性表的操作的一个子集。 插入和删除操作的位置受到限制。 3.2 栈的顺序存储结构（顺序栈） （一）构造原理 描述栈的顺序存储结构最简单的方法是
typedef struct 的用法
w_45678910的博客
03-27 4237
结构体类型定义 定义方式1： Typedef struct LNode { int data; //数据域 struct LNode *next; //指针域 } *LinkList; 定义方式2： struct LNode { int data; //数据域 struct LNode *next; //指针域 }; typedef struct LNode *LinkList; 以上两个定义方式是等价的。 是将 *LinkList 定义为 struct L
用操作符堆栈和操作数堆栈实现四则运算表达式
熊果屋的博客
04-14 1819
学习了用用操作符堆栈和操作数堆栈实现四则运算表达式的基本思想和实现后，在https://blog.csdn.net/cyq0318/article/details/78633752/的基础上自己动手实现了一下，代码全部在CodeBlocks 下测试通过。 堆栈实现代码如下： #ifndef _DATA_STRUCT_H #define _DATA_STRUCT_H typedef stru...
7.C++ Stack栈类模版实现
抵抗时间扭曲，坚持做一件有意义的事
02-24 2208
1.栈的介绍 栈的实现方式分为3种 基于静态数组实现,内部预设一个很大的数组对象, 实现简单，缺点是空间受限。 基于动态数组实现,内部预设一个容量值,然后分配一段内存空间数组,如果入栈大于默认容量值时,则再次扩大分配新的内存数组,并将旧数组拷贝至新数组及释放旧数组. 基于双向循环链表实现 栈的函数需要实现如下所示: T pop() : 出栈并返回栈顶元素 const T & pop() const : 出栈并返回const类型栈顶元素 void push(const T &a.
数据结构入门（四）-栈的定义与实现
Gedeon
02-10 7671
1.栈的定义栈(stack)是限定仅在标尾进行插入和删除操作的线性表。 我们把允许插入和删除的一端称为栈顶，另一端称为栈底，不含任何数据元素的栈称为空栈。栈又称为后进后出（Last In First Out)的线性表简称==LIFO==结构 很多软件比如 Word,Photoshop等文档或图像编辑软件中都有撤销（undo)的操作，也就是用栈的方式来实现的。 栈的插入操作，叫做进栈，也
C语言实现数据结构：栈与ADT抽象
总结来说，这份资料涵盖了数据结构的基础知识，包括栈的实现、ADT的概念和运用，以及C语言编程技巧，强调了理论与实践的结合，特别是如何通过抽象和信息隐蔽来设计高效的数据结构。同时，还介绍了在实际问题中的应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值