数据结构--栈的实现（C语言）

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

目录

声明

以下内容仅供学习，如有侵权，联系作者删除。
参考文献：王道考研系列数据结构、B站up主：C语言技术网
链接: C语言技术网

一 栈的基本概念

1.栈的定义

栈（Stack）：只允许在一端进行插入或删除的线性表。
栈顶（Top）：线性表允许进行插入和删除的那一端。
栈底（Bottom）：固定的，不允许进行插入和删除的另一端。
空栈：不含任何元素的空表。

2.栈的基本操作

由以下代码给出。

二 栈的顺序存储结构

代码.

/*
 * 程序名：seqstack1.c，此程序演示顺序栈的实现，数据元素是整数。
 * 作者：jack 日期：20210616
 * 参考作者：C语言技术网(www.freecplus.net), B站UP主：C语言技术网
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAXSIZE 10       // 顺序栈的最大长度。

typedef int ElemType;   // 自定义顺序栈的数据元素为整数。

typedef struct
{
	ElemType data[MAXSIZE];  // 用数组存储顺序栈中的元素。
	int top;                 // 栈顶指针，从0到MAXSIZE-1，-1表示空栈。
							 // 也可以从1到MAXSIZE，0表示空栈。
}Seqstack, *PSeqStack;

// 顺序栈SS的初始化操作。
void InitStack(PSeqStack SS);

// 清空顺序栈。
void ClearStack(PSeqStack SS);

// 求顺序栈的长度，返回值：栈SS中元素的个数。
int Length(PSeqStack SS);

// 判断顺序栈是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PSeqStack SS);

// 判断顺序栈是否为空，返回值：1-空，0-非空或失败。
int IsEmpty(PSeqStack SS);

// 元素入栈，返回值：0-失败；1-成功。
int Push(PSeqStack SS, ElemType *ee);

// 元素出栈，返回值：0-失败；1-成功。
int Pop(PSeqStack SS, ElemType *ee);

// 获取栈顶元素，返回值：0-失败；1-成功。
// 只查看栈顶元素的值，元素不出栈。
int GetTop(PSeqStack SS, ElemType *ee);

// 打印顺序栈中全部的元素。
void PrintStack(PSeqStack SS);

// 销毁顺序栈SS。
void DestroyStack(PSeqStack SS);

int main()
{
	Seqstack S;  // 创建顺序栈。

	InitStack(&S);

	printf("栈的长度是%d\n", Length(&S));
	ElemType e;     // 创建一个数据元素。

	printf("元素（1、2、3、4、5、6、7、8、9、10）入栈。\n");
	e = 1;  Push(&S, &e);
	e = 2;  Push(&S, &e);
	e = 3;  Push(&S, &e);
	e = 4;  Push(&S, &e);
	e = 5;  Push(&S, &e);
	e = 6;  Push(&S, &e);
	e = 7;  Push(&S, &e);
	e = 8;  Push(&S, &e);
	e = 9;  Push(&S, &e);
	e = 10; Push(&S, &e);

	printf("栈的长度是%d\n", Length(&S));

	// 只查看栈顶元素的值，元素不出栈。
	if (GetTop(&S, &e) == 1)  printf("栈顶的元素值为%d\n", e);

	PrintStack(&S);
	if (Pop(&S, &e) == 1)  printf("出栈的元素值为%d\n", e);
	if (Pop(&S, &e) == 1)  printf("出栈的元素值为%d\n", e);
	if (Pop(&S, &e) == 1)  printf("出栈的元素值为%d\n", e);
	if (Pop(&S, &e) == 1)  printf("出栈的元素值为%d\n", e);
	if (Pop(&S, &e) == 1)  printf("出栈的元素值为%d\n", e);
	if (Pop(&S, &e) == 1)  printf("出栈的元素值为%d\n", e);
	if (Pop(&S, &e) == 1)  printf("出栈的元素值为%d\n", e);
	if (Pop(&S, &e) == 1)  printf("出栈的元素值为%d\n", e);
	if (Pop(&S, &e) == 1)  printf("出栈的元素值为%d\n", e);
	if (Pop(&S, &e) == 1)  printf("出栈的元素值为%d\n", e);

	// 当所有元素出栈后
	
	if (Pop(&S, &e) == 1)  printf("出栈的元素值为%d\n", e);
	if (Pop(&S, &e) == 1)  printf("出栈的元素值为%d\n", e);

	return 0;
}

// 顺序栈SS的初始化操作。
void InitStack(PSeqStack SS)
{
	ClearStack(SS); // 清空顺序栈。
}

// 清空顺序栈。
void ClearStack(PSeqStack SS)
{
	if (SS == NULL) return; // 检查空指针。
	SS->top = -1;  // 栈顶指针置为-1。
	memset(SS->data, 0, sizeof(ElemType)*MAXSIZE);
}

// 求顺序栈的长度，返回值：栈SS中元素的个数。
int Length(PSeqStack SS)
{
	if (SS == NULL) return 0; // 检查空指针。
	return SS->top + 1;
}

// 判断顺序栈是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PSeqStack SS)
{
	if (SS == NULL) return 0;  // 检查空指针。

	if (SS->top >= MAXSIZE - 1) return 1;

	return 0;
}

// 判断顺序栈是否为空，返回值：1-空，0-非空或失败。
int IsEmpty(PSeqStack SS)
{
	if (SS == NULL) return 0;  // 检查空指针。

	if (SS->top == -1) return 1;
	return 0;
}

// 元素入栈，返回值：0-失败；1-成功。
int Push(PSeqStack SS, ElemType *ee)
{
	if ((SS == NULL) || (ee == NULL)) return 0;  // 检查空指针。

	if (IsFull(SS) == 1)
	{
		printf("顺序栈已满，不能插入。\n"); return 0;
	}

	SS->top++;  // 栈指针先加1。
	memcpy(&SS->data[SS->top], ee, sizeof(ElemType));  // 用数组的下标访问。
	return 1;
}

// 元素出栈，返回值：0-失败；1-成功。
int Pop(PSeqStack SS, ElemType *ee)
{
	if ((SS == NULL) || (ee == NULL)) return 0;  // 检查空指针。

	if (IsEmpty(SS) == 1) { printf("栈为空。\n"); return 0; }

	memcpy(ee, SS->data + SS->top, sizeof(ElemType));  // 采用指针运算也可以。
	SS->top--;  // 栈指针1。

	return 1;
}

// 获取栈顶元素，返回值：0-失败；1-成功。
// 只查看栈顶元素的值，元素不出栈。
int GetTop(PSeqStack SS, ElemType *ee)
{
	if ((SS == NULL) || (ee == NULL)) return 0;  // 检查空指针。

	if (IsEmpty(SS) == 1) { printf("栈为空。\n"); return 0; }

	memcpy(ee, SS->data + SS->top, sizeof(ElemType));  // 采用指针运算也可以。

	return 1;
}

// 打印顺序栈中全部的元素。
void PrintStack(PSeqStack SS)
{
	if (SS == NULL) return;  // 检查空指针。

	if (SS->top == -1) { printf("栈为空。\n"); return; }

	int kk;
	for (kk = 0; kk <= SS->top; kk++)
	{
		printf("SS[%d],value=%d\n", kk, SS->data[kk]);     // 用数组的下标访问。
		// printf("SS[%d],value=%d\n",kk,*(SS->data+kk));   // 采用指针运算也可以。
	}
}

// 销毁顺序栈SS。
void DestroyStack(PSeqStack SS)
{
	// 静态顺序栈无需释放内存，不需要销毁操作。

	ClearStack(SS); // 清空顺序栈。

	return;
}

顺序栈运行结果如下：
visual studio 2017

三 栈的链式存储结构

代码.

/*
* 程序名：seqstack1.c，此程序演示链栈的实现，数据元素是整数。
* 作者：jack 日期：20210616
* 参考作者：C语言技术网(www.freecplus.net), B站UP主：C语言技术网
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef int ElemType;    // 自定义链栈的数据元素为整数。

typedef struct SNode
{
   ElemType data;       // 链栈中的元素。
   struct SNode *next;  // 指向下一个结点的指针。
}SNode, *LinkStack;

// 链栈SS的初始化操作，分配头结点，返回头结点的地址。
SNode *InitStack();

// 销毁链栈SS。
void DestroyStack(LinkStack SS);

// 元素入栈，返回值：0-失败；1-成功。
int Push(LinkStack SS, ElemType *ee);

// 元素出栈，返回值：0-失败；1-成功。
int Pop(LinkStack SS, ElemType *ee);

// 求链栈的长度，返回值：栈SS中元素的个数。
int  Length(LinkStack SS);

// 清空链栈。
void Clear(LinkStack SS);

// 判断链栈是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(LinkStack SS);

// 打印链栈中全部的元素。
void PrintStack(LinkStack SS);

// 获取栈顶元素，返回值：0-失败；1-成功。
// 只查看栈顶元素的值，元素不出栈。
int GetTop(LinkStack SS, ElemType *ee);

int main()
{
   LinkStack S;     // 创建链栈。

   S = InitStack();  // 初始化链栈。

   printf("栈的长度是%d\n", Length(S));

   ElemType e;     // 创建一个数据元素。

   printf("元素（1、2、3、4、5、6、7、8、9、10）入栈。\n");
   e = 1;  Push(S, &e);
   e = 2;  Push(S, &e);
   e = 3;  Push(S, &e);
   e = 4;  Push(S, &e);
   e = 5;  Push(S, &e);
   e = 6;  Push(S, &e);
   e = 7;  Push(S, &e);
   e = 8;  Push(S, &e);
   e = 9;  Push(S, &e);
   e = 10; Push(S, &e);

   printf("栈的长度是%d\n", Length(S));

   if (GetTop(S, &e) == 1)  printf("栈顶的元素值为%d\n", e);

   PrintStack(S);

   if (Pop(S, &e) == 1)  printf("出栈的元素值为%d\n", e);
   if (Pop(S, &e) == 1)  printf("出栈的元素值为%d\n", e);
   if (Pop(S, &e) == 1)  printf("出栈的元素值为%d\n", e);
   if (Pop(S, &e) == 1)  printf("出栈的元素值为%d\n", e);
   if (Pop(S, &e) == 1)  printf("出栈的元素值为%d\n", e);
   if (Pop(S, &e) == 1)  printf("出栈的元素值为%d\n", e);
   if (Pop(S, &e) == 1)  printf("出栈的元素值为%d\n", e);
   if (Pop(S, &e) == 1)  printf("出栈的元素值为%d\n", e);
   if (Pop(S, &e) == 1)  printf("出栈的元素值为%d\n", e);
   if (Pop(S, &e) == 1)  printf("出栈的元素值为%d\n", e);

   // 当所有元素出栈后
   
   if (Pop(S, &e) == 1)  printf("出栈的元素值为%d\n", e);
   if (Pop(S, &e) == 1)  printf("出栈的元素值为%d\n", e);

   // 销毁链栈SS。
   DestroyStack(S); S = 0;  // 销毁链栈后把SS置为空，防止野指针。

   return 0;
}

// 链栈SS的初始化操作，分配头结点，返回头结点的地址。
SNode *InitStack()
{
   SNode *head = (SNode *)malloc(sizeof(SNode));  // 分配头结点。

   if (head == NULL) return NULL;  // 内存不足，返回失败。

   head->next = NULL;  // 头结点的下一结点暂时不存在，置空。

   return head;
}


// 清空链栈。
void Clear(LinkStack SS)
{
   // 清空链栈SS是指释放链栈全部的结点，但不包括头结点。
   if (SS == NULL) return;  // 检查空指针。

   SNode *tmp1;
   SNode *tmp2 = SS->next;  // 保留头结点，从头结点的下一个结点开始释放。

   while (tmp2 != NULL)
   {
   	tmp1 = tmp2->next;
   	free(tmp2);
   	tmp2 = tmp1;
   }

   SS->next = NULL; // 这行代码一定不能少，否则会留下野指针。

   return;
}

// 求链栈的长度，返回值：栈SS中元素的个数。
int  Length(LinkStack SS)
{
   if (SS == NULL) return 0; // 检查空指针。

   SNode *pp = SS->next;  // 头结点不算，从第1个结点开始。

   int length = 0;

   while (pp != NULL) { pp = pp->next; length++; }

   return length;
}

// 销毁链栈SS。
void DestroyStack(LinkStack SS)
{
   // 销毁链栈SS是指释放链栈全部的结点，包括头结点。
   SNode *tmp;

   while (SS != NULL)
   {
   	tmp = SS->next;  // tmp保存下一结点的地址。
   	free(SS);      // 释放当前结点。
   	SS = tmp;        // SS指针移动到下一结点。
   }

   // SS=NULL;   // SS在本函数中相当于局部变量，就算置空了也不会影响调用者传递的SS，
   					  // 所以SS=NULL没有意义。

   return;
}

// 判断链栈是否为空，返回值：1-空，0-非空或失败。
int IsEmpty(LinkStack SS)
{
   if (SS == NULL) return 0;   // 检查空指针。

   if (SS->next == NULL) return 1;

   return 0;
}

// 打印链栈中全部的元素。
void PrintStack(LinkStack SS)
{
   if (SS == NULL) return; // 检查空指针。

   if (SS->next == NULL) { printf("栈为空。\n"); return; }

   int kk = 0;
   SNode *pp = SS->next;  // 从第1个结点开始。

   while (pp != NULL)
   {
   	printf("SS[%d],value=%d\n", kk++, pp->data);
   	pp = pp->next;
   }
}

// 元素出栈，返回值：0-失败；1-成功。
int Pop(LinkStack SS, ElemType *ee)
{
   if ((SS == NULL) || (ee == NULL)) return 0;  // 检查空指针。

   if (SS->next == NULL) { printf("栈为空。\n"); return 0; }

   SNode *tmp = SS->next;

   memcpy(ee, &tmp->data, sizeof(ElemType));

   SS->next = tmp->next;

   free(tmp);

   return 1;
}

// 获取栈顶元素，返回值：0-失败；1-成功。
// 只查看栈顶元素的值，元素不出栈。
int GetTop(LinkStack SS, ElemType *ee)
{
   if ((SS == NULL) || (ee == NULL)) return 0;  // 检查空指针。

   if (SS->next == NULL) { printf("栈为空。\n"); return 0; }

   memcpy(ee, &SS->next->data, sizeof(ElemType));

   return 1;
}

// 元素入栈，返回值：0-失败；1-成功。
int Push(LinkStack SS, ElemType *ee)
{
   if ((SS == NULL) || (ee == NULL)) return 0;  // 检查空指针。

   SNode *tmp = (SNode *)malloc(sizeof(SNode));  // 分配一个结点。
   if (tmp == NULL) return 0;  // 内存不足，返回失败。

   // 考虑数据元素为结构体的情况，这里采用了memcpy的方法而不是直接赋值。
   memcpy(&tmp->data, ee, sizeof(ElemType));

   // 处理next指针。
   tmp->next = SS->next;
   SS->next = tmp;

   return 1;
}

链栈运行结果如下：
在这里插入图片描述

四 小结

1.代码复制后，就可以跑起来。
2.先讲到这里。后续剖析函数调用栈以及栈的一些应用。

jack学编程
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构---栈的实现
shijinghe的博客
03-27 3204
一、栈 学习栈之前我们需要认识栈究竟是什么东西。 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶 图解↓： 图中数据都是从栈顶进入，当图中1，2，3，4都进入，先出栈的只能是4，但也可以边进边出，举例：所以不一定出栈顺序就是4 3 2 1..
数据结构：栈-C语言实现
柿子__
11-20 2157
数据结构：栈-C语言实现，图文详讲，有注解和完整的代码
数据结构：栈C语言实现
weixin_51885188的博客
11-08 1576
目录 栈的概念及结构 栈的实现 栈的初始化 栈的销毁 压栈 出栈 返回栈顶的元素 统计栈中的元素个数 判断栈是否为空 栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一段进行插入和删除元素操作。进行数据插入和删除操作的一段被称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO(Last In First Out)的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。 它这个结构有点类似于子弹的弹夹，我们.
数据结构栈(C语言实现)
m0_69888254的博客
08-06 221
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端 称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。...
数据结构--栈（C语言实现）
weixin_51273111的博客
11-07 487
文章目录一、栈的基本概念1.栈的定义2.栈的特点3.栈的存储结构4.栈的数学性质二、结构体的定义三、顺序栈1.顺序栈的要素2.初始化栈3.判空4.进栈5.出栈四、链栈1.链栈的要素2.初始化3.判空4.进栈5.出栈 一、栈的基本概念 1.栈的定义 栈是一种只能在一端进行插入或删除的线性表。其中允许进行插入或删除操作的一端称为栈顶（top）。栈的插入和删除操作一般称作入栈和出栈。 2.栈的特点 先进后出 3.栈的存储结构 顺序栈和链式栈 注意：链式栈通常采用单链表实现，并规定所有的操作都是在单链表的表头进行的
数据结构-栈的C语言实现
01-20
数据结构-栈的C语言实现，随手笔记
数据结构--栈 的C语言实现.zip
最新发布
06-14
在众多的数据结构中，栈是一种非常基础且重要的类型，它遵循“后进先出”（LIFO）的原则。本教程将深入探讨栈的概念以及如何使用C语言实现它。 栈是一种线性数据结构，它的主要操作包括压栈（push）和弹栈（pop）。...
C语言-数据结构-栈队列实现
03-10
本主题关注的是如何使用C语言来实现数据结构中的栈和队列，这是两种基础但非常重要的抽象数据类型（ADT）。 栈（Stack）是具有后进先出（LIFO）特性的数据结构。它类似于一个堆叠的盘子，最新的元素被放在顶部，...
数据结构-链式栈应用实例-C语言实现判定字符串括号是否配对-数据结构学习
05-27
C语言实现判定输入字符串中的括号是否配对...本实例用于C语言以及数据结构中栈的学习，此外， 链式栈的.c和.h文件实现了以下功能： 创建链式栈 入栈 判断栈是否为空 出栈 清空栈 销毁栈 打印栈（为了便于观察实验现象）
数据结构初阶之栈（C语言实现）
Britney_dark的博客
04-26 3359
1. 概念及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端 称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈。入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。 进栈如下： 出栈如下： 注：内存中的栈和数据结构中的栈没有关系 ，一个是数据结构里的，一个是操作系统中内存划分的一个区域，叫做栈，用来函数调用时建立栈帧。
c语言是实现数据结构中的栈
qq_68695298的博客
09-05 492
c语言实现数据结构中的栈
一文解决数据结构——栈（C语言实现）
高星熠的博客
02-01 1672
一文搞定数据结构之栈（C语言实现）何为栈？栈的状态 何为栈？ 栈（Stack）：就是只允许在一端（限定只在表尾）进行插入或删除操作的线性表。 所以，对于栈而言，是有所区分栈顶（top）和栈底（bottom） 的。具体就如下图： 所以，在使用栈的存储时，是存在先进后出的一个规律。 当我们将元素依次存储入栈后，最先进栈储存的元素在取出（出栈）时，是需要等到后入栈压在其上的元素被全部取出后，才能出栈。 栈的状态 一个栈它是有着四种不同的状态 空栈 满栈 入栈 出栈 ...
数据结构C语言实现-栈
weixin_46935703的博客
05-11 226
仅利用C语言实现栈，及相关操作
详解C语言如何实现数据结构-栈
JuLiJuLi.的博客
07-21 386
栈的概念及结构 栈：它是一种特殊的线性表，它只允许在固定的一端进行插入和删除元素的操作。而用来进行**数据插入和删除操作**的一端叫做栈顶，另一端叫做栈底。栈中的数据元素遵守**后进先出**LIFO(Last In First Out)的原则。 **压栈**：栈的插入操作叫做压栈/入栈 等，入数据只能在栈顶上操作 **出栈**：栈的删除操作叫做出栈，出数据也只能在栈顶上操作...............
数据结构角度进行出栈、入栈操作
qq690759219的博客
05-01 399
#include&lt;stdio.h&gt;#include&lt;malloc.h&gt;#include&lt;stdlib.h&gt;typedef struct Node{ int data; struct Node * pNext;}NODE,* PNODE;typedef struct Stack{ PNODE pTop; PNODE pBottom;}STACK,* PSTACK;...
数据结构——栈（C语言实现）
yue152152的博客
03-26 1283
栈的概念与结构，栈的C语言实现
【数据结构】栈(实现+原码)
Edward_Asia的博客
10-31 1184
栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。 栈中的数据元素遵守后进先出LIFO（Last In First Out）原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。 栈的实现 栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。 #pragma once #include<s.
栈-数据结构(C语言)
weixin_44681349的博客
05-13 1100
栈 我们在用浏览器打开网页的时候，时常会点击页面上的某个链接跳转到其它页面浏览，又会在新的页面上，点击链接跳转到另一个新页面。另外，如果想回到上一个页面，就会点击浏览器的“返回”按钮，再点击一下又会返回上一个页面，而且每次点击“返回”只能返回上一级，浏览器的这个功能是怎么实现的呢？ 浏览器的这个功能可以用 栈 来实现，当前浏览的页面我们叫它为栈顶元素，跳转到一个新页面我们叫元素入栈，点击“返回”按钮我们叫元素出栈，当然出栈前提是栈里要有元素，比如在浏览器里，如果已经返回到了最开始的页面，那就无法返回了。 栈
matlab符号对象
DXFGJ的博客
09-13 1875
从本节开始，后续章节小编将和大家分享的模块是matlab中的符号计算。 众所周知，科学计算包括数值计算和符号计算两种计算，对于符号计算，符号计算又称计算机代数，通俗地说就是用计算机推导数学公式，如对表达式进行因式分解、化简、微分、积分、解代数方程、求解常微分方程等。 我们在使用matlab的时候，有时会到一些函数表式之类的公式，并非全是数值类型的结构，这时，掌握matlab的符号运算能力也是很有必要的，因此，本节将为大家介绍什么是符号对象。 一、符号对象的建立 首先，符号对象是Matlab中一种特殊的数据类
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值