【数据结构】—手把手带你用C语言实现栈和队列（超详细！）

已于 2023-09-17 08:58:47 修改
阅读量1.8k 收藏 45
点赞数 29
分类专栏： 数据结构与算法炼体 淬体中 文章标签： c语言 开发语言 数据结构 链表 学习
于 2023-08-07 15:36:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64038246/article/details/132144326
版权

                                  食用指南：本文在有C基础的情况下食用更佳 

                                 🔥这就不得不推荐此专栏了：C语言

                                 ♈️今日夜电波：Tell me —milet

                                               3:12 ━━━━━━️💟──────── 4:13                                                                                                                                     🔄   ◀️   ⏸   ▶️    ☰

                                💗关注👍点赞🙌收藏您的每一次鼓励都是对我莫大的支持😍 

目录

🌸🌸后进先出—栈

什么是栈？

 什么是后进先出？

 栈的实现？

栈实现需要设置的参数 ？

 要实现的功能？

🌸栈的C语言代码实现

🌷初始化

🌷入栈

🌷判空

🌷 出栈

🌷取栈顶元素

🌷计算栈内数据个数 

🌷销毁栈

🌸栈的整体代码

头文件

函数实现

测试用例

💮💮先进先出—队列

什么是队列？

什么是先进先出？ 

 队列的实现？

队列的实现需要设置的参数？ 

 要实现的功能？

💮队列的C语言实现

🌼初始化

🌼入队列 

🌼判空 

🌼出队列 

🌼 取头节点元素

🌼取尾节点元素

🌼计算队列内数据个数

🌼销毁队列

💮队列的整体代码

头文件

函数实现

测试用例

后进先出—栈

什么是栈？

        栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

 什么是后进先出？

        一图让你明白~

 栈的实现？

        栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。但是由于数组是在定义完后对于空间是固定的，因此如果单纯用数组实现，如果申请空间过大会浪费空间，太小又会造成空间不够的问题，因此，本文采用支持动态增长的栈，也就是动态开辟空间的方法。

         对此，我们先了解一下咱们栈的操作

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶。 

栈实现需要设置的参数 ？

        由于咱们要实现的是动态扩容因此定义如下：

// 支持动态增长的栈
typedef int STDataType;

typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;

        此处对于相关栈所定义的元素进行解释：

       1、 STDataType* _a 作为动态扩容的作用。

        2、int _top 作为记录栈顶位置的作用。

        3、int _capacity 作为记录栈容量的作用。

啥意思呢？

         一图让你明白~

 要实现的功能？

        同我们之前所学的链表、线性表一样，需要实现基本的增、删、查、改！但是需要注意的是，我们的查与修只能在固定的一端进行！而不能进行改的操作！对此我们写出相应的接口函数。

// 初始化栈 
void StackInit(Stack* ps);
// 入栈 
void StackPush(Stack* ps, STDataType data);
// 出栈 
void StackPop(Stack* ps);
// 获取栈顶元素 
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数 
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);

栈的C语言代码实现

初始化

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

	ps->_a = NULL;

	ps->_capacity = 0;

	ps->_top = -1;
}

        注意：解释一下为什么这里top要设置成-1，主要是因为后续的操作中，比如：判空的操作的差异、在入栈时操作的差异，当然，top也可以设置成0，但后续的操作会有所差异。

入栈

void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->_capacity - 1 == ps->_top)//匹配上初始化top=-1
	{
		int newcap = ps->_capacity == 0 ? MAX : ps->_capacity * 2;

		STDataType* tmp = (STDataType*)realloc(ps->_a, newcap*sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		ps->_capacity = newcap;
		ps->_a = tmp;
	}

	ps->_a[++ps->_top] = data;
}

        入栈时首先判断空间是否足够，如果不够则扩容，够则直接入栈

判空

int StackEmpty(Stack* ps)
{
	assert(ps);

	return ps->_top==-1;
}

 出栈

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

	assert(!StackEmpty(ps));

	ps->_top--;
}

取栈顶元素

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

	assert(!StackEmpty(ps));

	ps->_top--;
}

计算栈内数据个数 

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top+1;
}

销毁栈

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

	free(ps->_a);
	ps->_a = NULL;

}

栈的整体代码

头文件

#pragma once
#define _CRT_SECURE_NO_WARNINGS 01
#define MAX 4
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
// 支持动态增长的栈
typedef int STDataType;

typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;

// 初始化栈 
void StackInit(Stack* ps);
// 入栈 
void StackPush(Stack* ps, STDataType data);
// 出栈 
void StackPop(Stack* ps);
// 获取栈顶元素 
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数 
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);

函数实现

#include "stack.h"

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

	ps->_a = NULL;

	ps->_capacity = 0;

	ps->_top = -1;
}

void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->_capacity - 1 == ps->_top)
	{
		int newcap = ps->_capacity == 0 ? MAX : ps->_capacity * 2;

		STDataType* tmp = (STDataType*)realloc(ps->_a, newcap*sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		ps->_capacity = newcap;
		ps->_a = tmp;
	}

	ps->_a[++ps->_top] = data;
}

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

	assert(!StackEmpty(ps));

	ps->_top--;
}

STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->_a[ps->_top];
}

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top+1;
}

int StackEmpty(Stack* ps)
{
	assert(ps);

	return ps->_top==-1;
}

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

	free(ps->_a);
	ps->_a = NULL;

}

测试用例

#include"stack.h"

void test()
{
	Stack st;
	StackInit(&st);
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPop(&st);
	StackPush(&st, 4);
	StackPush(&st, 5);

	printf("%d\n", StackSize(&st));
	while (!StackEmpty(&st))
	{
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}
	printf("\n%d\n", StackSize(&st));
	StackDestroy(&st);
}

int main()
{
	test();
	
	return 0;
}

测试结果：

先进先出—队列

什么是队列？

        队列只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头。

什么是先进先出？ 

        相信在前面了解过后进先出的你应该有一定的概念了，一图让你明白~

 队列的实现？

        队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。 

队列的实现需要设置的参数？ 

        根据链表的定义如下：

typedef int QDataType;
// 链式结构：表示队列 

typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
}Queue;

        注意：QNode是基本的链表结构，而在QNode的基础上建立的Queue是作为真正的队列的结构，其中  _front 是作为记录队头位置的一个指针，而相应的  _rear 是作为记录队尾位置的一个指针。

        一图让你明了~ 

 要实现的功能？

        同我们之前所学的链表、线性表一样，需要实现基本的增、删、查、改！但是需要注意的是，增的操作在一端进行，而删的操作在另外一端进行，并且同栈一样不能进行改的操作！对此我们写出相应的接口函数。

// 初始化队列 
void QueueInit(Queue* q);
// 队尾入队列 
void QueuePush(Queue* q, QDataType data);
// 队头出队列 
void QueuePop(Queue* q);
// 获取队列头部元素 
QDataType QueueFront(Queue* q);
// 获取队列队尾元素 
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数 
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);

队列的C语言实现

初始化

void QueueInit(Queue* q)
{
	assert(q);

	q->_front = NULL;

	q->_rear = NULL;
}

        你可能有个问题？为什么需要将两个指针都置空呢？初始化指针是一方面，而最主要的是为了让两个指针在最开始都指向同一个位置，然后头指针（也就是front）是只有在出队时才会移动的！尾指针（也就是rear）是只有在出队时才会移动的！这也是后续判空等操作的关键。

入队列 

void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->_next = NULL;
	newnode->_data = data;

	if (q->_rear == NULL)
	{
		assert(q->_front == NULL);

		q->_front = q->_rear = newnode;
	}
	else
	{
		q->_rear->_next = newnode;
		q->_rear = newnode;
	}
}

     入队列时需要判断头、尾指针是否为都为空，以此来确定是在头部插入还是在尾部插入。

判空 

int QueueEmpty(Queue* q)
{
	assert(q);

	return q->_front==NULL&&q->_rear==NULL;
}

        当头指针与尾指针都为空时，即该对列为空。

出队列 

void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(&q));

	if (q->_front == q->_rear)//一个节点
	{
		free(q->_front);
		q->_front = NULL;
		q->_rear = NULL;
	}
	else
	{
		QNode* next = q->_front->_next;
		free(q->_front);
		q->_front = next;
	}

}

        出队列需要判断为一个节点还是多个节点的问题，一个节点则需要在释放空间的基础上再将两个指针置空，剩余多个则仅需将出队节点置空。

 取头节点元素

QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(&q));

	return q->_front->_data;
}

取尾节点元素

QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(&q));

	return q->_rear->_data;
}

计算队列内数据个数

int QueueSize(Queue* q)
{
	QNode* cur = q->_front;
	int size = 0;
	if (cur != NULL)
	{
		size++;
		while (cur != q->_rear)
		{
			size++;
			cur = cur->_next;
		}

	}	
		return size;
	
}

销毁队列

void QueueDestroy(Queue* q)
{
	assert(q);

	QNode* cur = q->_front;
	while (cur)
	{
		QNode* next = cur->_next;
		free(cur);

		cur = next;
	}
	q->_front = NULL;
	q->_rear = NULL;
}

队列的整体代码

头文件

#pragma once

#define _CRT_SECURE_NO_WARNINGS 01
#include <stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int QDataType;
// 链式结构：表示队列 

typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
}Queue;

// 初始化队列 
void QueueInit(Queue* q);
// 队尾入队列 
void QueuePush(Queue* q, QDataType data);
// 队头出队列 
void QueuePop(Queue* q);
// 获取队列头部元素 
QDataType QueueFront(Queue* q);
// 获取队列队尾元素 
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数 
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);

函数实现

#include "queue.h"

void QueueInit(Queue* q)
{
	assert(q);

	q->_front = NULL;

	q->_rear = NULL;
}

void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->_next = NULL;
	newnode->_data = data;

	if (q->_rear == NULL)
	{
		assert(q->_front == NULL);

		q->_front = q->_rear = newnode;
	}
	else
	{
		q->_rear->_next = newnode;
		q->_rear = newnode;
	}
}

void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(&q));

	if (q->_front == q->_rear)//一个节点
	{
		free(q->_front);
		q->_front = NULL;
		q->_rear = NULL;
	}
	else
	{
		QNode* next = q->_front->_next;
		free(q->_front);
		q->_front = next;
	}

}

QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(&q));

	return q->_front->_data;
}

QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(&q));

	return q->_rear->_data;
}

int QueueSize(Queue* q)
{
	QNode* cur = q->_front;
	int size = 0;
	if (cur != NULL)
	{
		size++;
		while (cur != q->_rear)
		{
			size++;
			cur = cur->_next;
		}

	}	
		return size;
	
}

int QueueEmpty(Queue* q)
{
	assert(q);

	return q->_front==NULL&&q->_rear==NULL;
}

void QueueDestroy(Queue* q)
{
	assert(q);

	QNode* cur = q->_front;
	while (cur)
	{
		QNode* next = cur->_next;
		free(cur);

		cur = next;
	}
	q->_front = NULL;
	q->_rear = NULL;
}

测试用例

#include"queue.h"

void test()
{
	Queue qu;
	QueueInit(&qu);
	QueuePush(&qu, 1);
	QueuePush(&qu, 2);
	printf("%d\n", QueueBack(&qu));

	QueuePush(&qu, 3);
	QueuePush(&qu, 4);
	
	printf("%d\n", QueueSize(&qu));
	while(!QueueEmpty(&qu))
	{
		printf("%d ", QueueFront(&qu));
		QueuePop(&qu);
	}
	printf("\n%d\n", QueueSize(&qu));

	QueueDestroy(&qu);
}

int main()
{
	test();
	return 0;
}

测试结果：

                      感谢你耐心的看到这里ღ( ´･ᴗ･` )比心，如有哪里有错误请踢一脚作者o(╥﹏╥)o！ 

                        ​​​​​​​                ​​​​​​​

                                                                           给个三连再走嘛~  

慕斯( ˘▽˘)っ
关注
  • 29
    点赞
  • 踩
  • 45
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 33
    评论
专栏目录
C语言实现动态数组队列
Hong_smallgod的博客
09-10 932
C语言实现动态数组队列
手把手指导编写数据结构（1）——C语言基础
机计复计机
02-23 1015
在正式开始学习数据结构之前，让我们回顾一下数据结构中经常会用到的C语言基础。
C语言栈和队列代码实现
08-08
包含内容：栈、队列、循环队列的数组实现方式和链表实现方式
C语言——栈与队列的实现
weixin_40203143的博客
12-28 3032
栈与队列都是受限的线性表，均可以通过顺序表（数组）和链表两种方式得到实现。只不过栈是FILO，队列是FIFO，即栈和队列在出和入的方式上有所不同。而通过数组和链表实现的区别，即为数组与链表本身的区别：数组的存储空间是连续的，不可动态扩展；链表的存储空间是不连续的，可以动态扩展。下面具体来说。 一、栈的实现： 栈有栈底和栈顶，栈底是固定的，栈顶指向栈最顶上的第一个数据；数据的入栈和出栈只能在栈顶...
C语言-栈和队列
最新发布
m0_73605503的博客
07-22 1222
欢迎来到HanLop博客的C语言数据结构初阶系列。在之前的文章中，我们详细介绍了链表及其操作方法。在本篇文章中，我们将深入探讨栈和队列这两种常见的数据结构。栈和队列虽然都是线性数据结构，但它们在数据的存取方式上有着显著的区别。栈是一种后进先出（LIFO, Last In First Out）的数据结构，而队列则是一种先进先出（FIFO, First In First Out）的数据结构。通过理解和掌握这两种数据结构，您将能更有效地管理数据，并为后续更复杂的数据结构和算法的学习打下坚实的基础。让我们一起开始探
C语言实现栈与队列
2301_79432671的博客
02-11 898
不直接定义一个数组，而采用realloc、malloc来动态管理顺序表大小，使栈的大小不再受限。再定义一个top栈顶指针来方便后续的增删操作。//将int类型重定义叫做MyDataType//一个MyDataType类型的指针，可以进行动态内存开辟//栈的最大容量int top;//用于栈顶指针}ST;队列是只允许在一端插入元素，另一端删除元素的线性表，特点是先进先出。Queue这个结构体中还包含两个QNode结点结构体。包含队列头尾结点，能够帮助从队尾插入和从队头删除。
C语言---栈和队列
qq_62743629的博客
05-01 3261
严格来说,栈和队列都属于线性表 "一对一" 栈:"先进后出" 队列: "先进先出" 栈 栈只能从一端存取,另一端是封闭的 在栈中,不论是存还是取,都必须遵循"先进后出"的原则 ==>栈是一种只能从表的一端存取数据,且遵循"先进后出"原则的线性存储结构 进栈和出栈 进栈:将数据存储到栈里面去 出栈:将数据从栈中间取出来 栈的实现方法 栈:有点"特殊"的线性存储结构 顺序表==>顺序栈 (顺序存储结构) 链表==>链栈 (链式存储结构)
c语言--栈和队列
weixin_61558111的博客
09-24 1938
栈的入栈和出栈操作 通常用指针top指向栈顶的位置，用指针bottom指向栈底，栈顶指针top动态反映栈的当前位置。栈是一种特殊的线性表，因此栈可采用顺序存储结构存储，也可以使用链式存储结构存储。栈中的数据元素用一个预设的足够长的一维数组来实现：。栈底位置可以设置在数组的任意端点，用来作为栈顶指针。 若现在有一个栈，StackSize是5，则栈的普通情况、空栈、满栈的情况分别如下图所示： 通常将0下标端设为栈底，这样空栈时栈顶指针s->top = -1；入栈时，栈顶指针s->top++；出栈时，s->
C语言手把手教你实现贪吃蛇AI（下）
08-28
通过以上讲解，我们可以看到实现贪吃蛇AI涉及的主要知识点包括：C语言基础，数据结构（如链表和二维数组），算法（如A*搜索和优先队列），以及游戏逻辑的构建。这个项目不仅可以帮助学习者巩固C语言编程技能，还能...
数据结构手把手教学——循环队列
Sanjay_Wu的博客
02-03 2675
文章不空谈理论，完全采用手把手教学，并有综合示例练习题，看完这篇，你绝对能掌握数据结构循环队列。
数据结构实战完全手册
06-10
不同于其他课程，本课程从单链表出发，手把手的全代码实现了栈与队列，树、图（包括数组和链表的两种形式），并对这些经典结构的应用也做了代码级的实现，覆盖了经典数据结构的全部内容. 课程参考教材：周幸妮教授的...
数据结构C语言实现栈和队列的基本操作
12-12
用C语言实现了栈和队列的数据结构形式，其中包括栈和队列的初始化，压栈弹栈，进队出堆。和一些其他的基本操作！
C语言 数据结构 栈和队列
CR7lmz的博客
07-27 199
一、栈 1、栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。 2、栈的实现 栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些...
C语言数据结构——栈和队列
zcxmjw的博客
12-27 369
本篇文章主要带领大家深入了解栈和队列以及相关实现。
数组、链表、队列和栈----队列，C语言实现
wangeil007的博客
07-22 182
队列，顾名思义就是很多个数据在排队。既然是排队，那就不能从最前面或者中间插进去，新来的数据只能排在队伍的最后。另外，我们另外规定只有队伍最前面的数据才能出去。当然，其实也只有队伍最前面的数据能被外界查看。能满足这种功能的数据结构称之为队列。 我们可以用数组、链表实现队列。这里用数组实现简单队列。 3.1 数组实现简单队列 申请10个位置的数组，用数组实现简单队列 int queue[10]; int capacity = 10; //队列的总容量为10 //队列的范围是head ~ tail int
C语言栈和队列的实现
k666499436的博客
05-28 4983
详细讲解栈与队列的定义和特性，用C语言分别实现顺序栈、链栈、顺序(循环)队列、链队列，已经顺序存储与链式存储的区别
C语言——栈和队列
super_coders的博客
05-14 467
ps->a我们有两种初始化方法，一种是直接malloc一个空间，可以是四个或者八个对象的空间，也可以像我一样，先不开，等会入栈的时候再开。栈是一种特殊的线性表，限定仅在表尾进行插入和删除的线性表。在进行入栈以前，先把top指向为栈顶的下一个数据，如果指向栈顶数据的话，初始化就不能为0。队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。栈的实现一般使用数组或者链表，因为cpu高速缓存的原因，使用数组也非常ok。希望这篇博客对你有所帮助！头文件：Queue.h。
【c语言实现栈和队列】
小小太空人的博客
03-16 495
栈的概念： 它是一种特殊的线性表，其只允许在固定的一端进行插入和删除操作。栈就像弹夹一样，先入栈的为栈底后入栈的为栈顶，出栈时只能先从栈顶出。（后进先出）LIFO（Last In First Out） 队列的概念： 只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表。进行插入操作的一端称为队尾，也就是入队列的操作。进行删除数据操作称为队头，也就是出队列的操作。（先进先出） 这里考虑用顺序表来实现栈，因为栈的结构特点是后进先出，那么意味着从顺...
"手把手教你HTML教程，带有多彩案例！
同时，你也可以通过添加CSS和JavaScript，来实现更丰富的页面布局和交互效果。 总结起来，本教程提供了一个全面而详细的HTML教学，通过手把手的教学方式、配备丰富的例子教程和多彩多字的案例，使你能够轻松掌握...
评论 33
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

慕斯( ˘▽˘)っ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值