数据结构算法刷题笔记——四、栈与队列

最新推荐文章于 2024-09-13 19:36:07 发布
最新推荐文章于 2024-09-13 19:36:07 发布
阅读量522 收藏
点赞数
分类专栏： 数据结构算法刷题笔记 文章标签： 数据结构 算法 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45029825/article/details/132645927
版权

数据结构算法刷题笔记——四、栈与队列

4.1 栈与队列

栈：限定仅在表尾进行插入和删除操作的线性表
队列：只允许在一端进行插入操作，在另一端进行删除操作的线性表

4.2 栈的定义

4.2.1栈的定义

栈(stack)：是限定仅在表尾进行插入和删除操作的线性表

  • 栈顶：允许插入和删除的一端
  • 栈底：栈顶的另一端
  • 空栈：不含任何数据元素的栈
  • LIFO：别名，后进先出（Last InFirst Out）的线性表
    • 栈是线性表
    • 栈元素具有线性关系（前驱后继关系）
    • 表尾——栈顶
    • 表头——栈底
  • 插入操作：进栈、压栈、入栈
  • 删除操作：出栈、弹栈

4.2.2 进栈出栈变换形式

保证栈顶元素先出栈就可以
在这里插入图片描述

4.3 栈的抽象数据类型

  • 理论上：线性表的操作特性它都具备
  • 针对它的特殊性：一些操作有一些变化
  • 插入和删除操作：改为 进栈push 和 出栈pop
    在这里插入图片描述在这里插入图片描述

4.4 栈的顺序存储结构及实现

4.4.1 栈的顺序存储结构

栈的顺序存储：顺序栈：线性表顺序存储的简化

  • 栈底：下标为0
  • 栈顶：top变量，指示栈顶元素在数组中的位置
    • top 小于等于存储站长度StackSize
  • 空栈：top == -1

栈的结构定义

typedef int SElemType;	/* SElemType类型根据实际情况而定，这里加黑色为int */
/* 顺序栈结构 */
typedef struct
{
	SElemType data[MAXSIZE];
	int top;			/* 用于栈顶指针 */
}SqStack;

在这里插入图片描述

4.4.2 栈的顺序存储结构——进栈操作 push

进栈操作 push

  • 时间复杂度O(1)
/* 插入元素e为新的栈顶元素 */
Status Push(SqStack *S, SElemType e)
{
	if(S->top == Maxize-1) {	/* 判断栈满 */
		return ERROR;
	}
	S->top++;								/* 栈顶指针增加一 */
	S->data[s->top] = e;			/* 将新插入元素赋值给栈顶空间 */
	return OK;
}

在这里插入图片描述

4.4.3 栈的顺序存储结构——出栈操作 pop

出栈操作 pop

  • 时间复杂度O(1)
/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
Status Pop(SqStack *S, SElemType *e)
{
	if(S->top == -1)			/* 栈为空，无可删除元素 */
	*e = S->data[S->top];	/* 将要删除的栈顶元素赋值给e */
	S->top--;						/* 栈顶指针减一 */
	return OK；
}

4.5 两栈共享空间

出发点：必须事先确定数组存储空间大小，万一不够用了，就需要用编程手段来扩展数组的容量
解决方案：两个相同类型的栈，用一个数组来存储这两个栈

  • 数组两个端点，作为两个栈的栈底
    • 下表为0，栈一的栈底
    • 下表为n-1，栈二的栈底
  • 两个栈的栈顶在数组中间，由两端向中间靠拢
    • top1 = -1，栈一为空栈
    • top2 = n，栈二为空栈
    • top1 + 1 == top2 ：栈满
  • 使用范围：当两个栈的空间需求有相反关系，一个栈增长时另一个栈缩短的情况

两栈共享空间结构：

/* 两栈共享空间结构 */
typedef struct
{
	SElemType data[MAXSIZE];
	int top1;		/* 栈1栈顶指针 */
	int top2;		/* 栈2栈顶指针 */
}SqDoubleStack;

两栈共享空间——插入元素 push

  • 函数参数需要一个判断是栈一或栈二的栈号参数stackNumber
  • 注意：++S->top1, --S->top2（插入元素，先自增长度，再赋值）
/* 插入元素e为新的栈顶元素 */
Status Push(SqDoubleStack *S, SElemType e, int stackNumber)
{
	if(S->top1 + 1 == S->top2)				/* 栈已满，不能再push新元素了 */
		return ERROR;
	if(stackNumber == 1)							/* 栈1 有元素进栈 */
		S->data[++S->top1] = e;					/* 若是栈1则先top1+1后给数组元素赋值 */
	else if(stackNumber == 2)
		S->data[--S->top2] == e;
	return OK;
}

两栈共享空间——删除元素 pop

  • 注意：S->top1–, S->top2++（删除元素，先赋值，再自减长度）
Status Pop(SqDoubleStack *S, SElemType *e, int stackNumber)
{
	if(stackNumber == 1){
		if(S->top1 == -1)					/* 判断栈1已经是空栈，则删除操作会溢出 */
			return ERROR;
		*e = S->data[S->top1--];		/* 将栈1的栈顶元素出栈 */
	}	
	else if(stackNumber == 2){
		if(S->top2 == MAXSIZE)
			return ERROR;
		*e = S->data[S->top2++];
	}
}

4.6 栈的链式存储结构及实现

4.6.1 栈的链式存储结构

栈的链式存储结构：简称链栈

  • 只有栈顶进行插入和删除操作
  • 栈顶：放在单链表的头部
    • 有了栈顶在头部，单链表中的头结点失去了意义，链栈基本没有头结点
  • 栈满：链栈基本不会栈满，除非计算机内存没空间
  • 空栈：top == NULL
  • 其他操作和单链表类似，在插入和删除上有一些特殊
/* 链栈结构 */
typedef struct StackNode
{
	SElemType data;
	struct StackNode *next;
}StackNode, * LinkStackPtr;

typedef struct
{
	LinkStackPtr top;			/* 栈顶指针 */
	int count;
}LinkStack;

在这里插入图片描述

4.6.2 栈的链式存储结构——进栈操作 push

进栈 push 操作：元素值为e的新节点s，top为栈的栈顶指针

  • 时间复杂度O(1)
/* 插入元素e为新的栈顶元素 */
Status Push(LinkStack *S, SElemType e)
{
	LinkStackPtr s = (LinkStackPtr)malloc(sizeof(StackNode));
	s->data = e;
	s->next = S->top;
	S->top = s;
	S->count++;
	return OK;
}

在这里插入图片描述

4.6.3 栈的链式存储结构——出栈操作 pop

链栈的出栈 pop 操作：变量p用来存储要删除的栈顶结点，将栈顶指针下移一位，最后释放p即可

  • 时间复杂度O(1)
/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK，否则返回ERROR */
Status Pop(LinkStack *S, SElemType *e)
{
	LinkStackPtr p;
	if(StackEmpty(*S))
		return ERROR;
	*e = S->top->data;
	p = S->top;							/* 将栈顶结点赋值给p */
	S-top = S->top->next;			/* 使得栈顶指针下移一位，指向后一结点 */
	free(p);									/* 释放指针p */
	S->count--;
	return OK;
}

链栈和顺序栈选择

  1. 用链栈：栈的使用过程中元素变化不可预料，有时很小，有时很大，最好用链栈
  2. 用顺序栈：栈的变化在可控范围内，使用顺序栈更好

4.7 栈的作用

栈的引入简化了程序设计的问题，划分了不同关注层次，使得思考范围缩小，更加聚焦于我们要解决的问题核心

4.8 栈的应用——递归

4.8.1 斐波那契数列的实现

斐波那契数列：前面相邻两项之和，构成了后一项
在这里插入图片描述在这里插入图片描述
打印前40位斐波那契数列：
迭代实现方法：

int main()
{
	int i;
	int a[40];
	a[0] = 0;
	a[1] = 1;
	printf("%d", a[0]);
	printf("%d", a[1]);
	for(i = 2; i < 40; i++){
		a[i] = a[i-1] + a[i-2];
		printf("%d", a[i]);
	}
	return 0;
}

递归实现方式：

/* 斐波那契的递归函数 */
int Fbi(int i)
{
	if(i < 2)
		return i = 0 ? 0 : 1;
	return Fbi(i-1)+Fbi(i-2);			/* 这里是Fbi就是函数自己，等于在调用自己 */
}

int main()
{
	int i;
	printf("递归显示斐波那契数列：\n");
	for(int i = 0; i < 40; i++){
		printf("%d",Fbii());
	}
	return 0;
}

在这里插入图片描述

4.8.2 递归的定义

递归函数：直接调用自己或通过一系列的调用语句间接地调用自己的函数

  • 每个递归定义必须至少有一个条件，满足时递归不再进行，即不再引用自身而是返回值推出

迭代和递归的区别：

  • 迭代：使用循环结构
    • 优点：不需要反复调用函数和占用内存
  • 递归：使用选择结构
    • 优点：是程序结构更简洁，更容易理解
    • 缺点：递归调用，会建立函数的副本，耗费大量的时间和内存

递归过程就是操作系统通过栈的形式实现的

  • 前行阶段：对每一层递归，函数的局部变量、参数值以及返回地址都被压入栈中
  • 退回阶段：位于栈顶的局部变量、参数值和返回值被弹出，用于返回调用层次中执行代码的其余部分，恢复了调用的状态

4.9 栈的应用——四则运算表达式求值

4.9.1 后缀（逆波兰）表示法的定义

栈的应用：比较常见的——数学表达式的求值
后缀表达法（逆波兰）：一种不需要括号的后缀表达法

  • 所有符号都要在运算数字的后面出现
  • 规则：从左到右遍历表达式的每个数字和符号，遇到是数字就进栈，遇到是符号，就将处于栈顶两个数字出栈，进行运算，运算结果进栈，一直到最终获得结果。

4.9.2 后缀表达式的计算结果

在这里插入图片描述

4.9.3 中缀表达式转后缀表达式

标准四则运算表达式：中缀表达式 ：9+（3-1）*3+10/2
中缀表达式——转换为——后缀表达式：

  • 规则：从左到右遍历终追你表达式的每个数字和符号，若是数字就输出，即成为后缀表达式的一部分；若是符号，则判断其与栈顶符号的优先级，是右括号或优先级不高于栈顶符号，则栈顶元素依次出栈并输出，并将当前符号进栈，一直到最终输出后缀表达式为止。

4.10 队列的定义

队列：只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

  • FIFO:一种先进先出的线性表，简称FIFO
  • 队尾：允许插入的一端
  • 队头：允许删除的一端
  • 排在第一个的优先出列，最后的在队伍最后
    在这里插入图片描述

4.11 队列的抽象数据类型

队列有类似于线性表的各种操作

  • 不同点：
    • 插入数据只能在队尾
    • 删除数据只能在队头
      在这里插入图片描述在这里插入图片描述

4.12 循环队列

队列也存在顺序存储和链式存储两种结构

4.12.1 队列顺序存储的不足

队列的顺序存储结构：按照最基础的数组存储形式

  • 插入操作：在队尾插入一个元素，不需要移动任何元素

    • 时间复杂度O(1)
      在这里插入图片描述

  • 删除操作：在队头出列，即下标为0的位置

    • 时间复杂度O(n)
      在这里插入图片描述

存在不足：每次出队（删除）都在队头下标为0的位置，性能大大增加
改进方式：队头不需要一定在下标为0的位置，循环队列的使用

  • 引入两个指针：
    • front指针：指向队头元素
    • rear指针：指向队尾元素的下一个位置

4.12.2 循环队列的定义

出发点：解决假溢出，后面满了，再从头开始，头尾相接的循环。
循环队列：队列的这种头尾相接的顺序存储结构成为循环队列

  • front指针：指向队头元素

  • rear指针：指向队尾元素的下一个位置

  • 队列空的条件：front == rear

  • 队列满时，保留一个元素空间

  • 队列满的条件：（rear+1）%QueueSize == front

    • 在这里插入图片描述

  • 队列长度：（rear-front+QueueSize）%QueueSize

  1. 循环队列的顺序存储结构
typedef int QElemType;		/* QElemType类型根据实际情况而定，这里假设为int */
/* 循环队列的顺序存储结构 */
typedef struct
{
	QElemType data[MAXSIZE];
	int front;							/* 头指针 */
	int rear;							/* 尾指针，若队列不空，指向队列尾元素的下一个位置 */
}SqQueue;
  1. 循环队列的初始化
/* 初始化一个空队列Q */
Status InitQueue(SqQueue *Q)
{
	Q->front = 0;
	Q->rear = 0;
	return OK;
}
  1. 循环队列求队列长度
/* 返回Q的元素个数，也就是队列的当前长度 */
int QueueLength(SqQueue Q)
{
	return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;
}
  1. 循环队列的入队操作
/* 若队列未满，则插入元素e为Q新的队尾元素 */
Status EnQueue(SqQueue *Q, QElemType e)
{
	if((Q->rear+1)%MAXSIZE == Q->front)			/* 队列满的判断 */
		return ERROR;
	Q->data[Q->rear] = e;										/* 将元素e插入到队尾 */
	Q->rear = (Q->rear+1)%MAXSIZE;					/* rear指针向后移一位置 */
																				/* 若到最后则转到数组头部 */
	return OK;
}
  1. 循环队列的出队操作
/* 若队列不空，则删除Q中队头元素，用e返回其值 */
Status DeQieie(SqQueue *Q, QElemType *e)
{
	if(Q->front == Q->rear)									/* 队列空的判断 */
		return ERROR;
	*e = Q->data[Q->front];									/* 队头元素赋值给e*/
	Q->front = (Q->front+1)%MAXSIZE;					/* front指针向后移一位置 */
																				/* 若到最后则转到数组头部 */
	return OK;
}

4.13 队列的链式存储结构及实现

循环队列的算法时间性能并不高，但是循环队列面临着数组可能会溢出的问题
需要研究一下不需要担心队列长度的链式存储结构
链队列：队列的链式存储结构，就是线性表的单链表，只不过它只能尾进头出

  • 队头指针：指向链队列的头结点
  • 队尾指针：指向终端结点
  • 空队列：front和rear都指向头结点
    在这里插入图片描述在这里插入图片描述

链队列的结构

typedef int QElemType;		/* QElemType类型根据实际情况而定，这里假设为int */
typedef struct QNode			/* 结点结构 */
{
	QElemType data;
	struct QNode *next;
}QNode, *QueuePtr;

typedef struct						/* 队列的链表结构 */
{
	QueuePtr front,rear;		/* 队头、队尾指针 */
}LinkQueue;

4.13.1 队列的链式存储接哦古——入队操作

入队操作

  • 在链表尾部插入结点
/* 插入元素e为Q的新的队尾元素 */
Status EnQueue(LinkQueue *Q, QElemType e)
{
	QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
	if(!s)									/* 存储分配失败 */
		exit(OVERFLOW);
	s->data = e;
	s->next = NULL;
	Q-rear->next = s;			/* 把拥有元素e的新节点s赋值给原队尾结点的后继 */
	Q->rear = s;						/* 把当前的额s设置为队尾结点，rear指向s */
	return OK;
}

在这里插入图片描述

4.13.2 队列的链式存储结构——出队操作

出队操作

  • 头结点的后继结点出队
  • 将头结点的额后继改为它后面的结点
  • 若链表除头结点外只剩下一个元素，则需将rear指向头结点

出队操作

/* 若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR */
Status DeQueue(LinkQueue *Q, QElemType *e)
{
	QueuePtr p;
	if(Q->front == Q->rear)
		return ERROR;
	p = Q->front->next;						/* 将欲删除的队头结点暂存给p */
	*e = p->data;								/* 将欲删除的队头结点的值赋值给e */
	Q->front->next = p->next;			/* 将原队头结点的后继p->next赋值给头结点后继 */
	if(Q->rear = p)							/* 若队头就是队尾，则删除后将rear指向头结点 */
		Q->rear = Q->front;
	free(p);
	return OK;
}

在这里插入图片描述

孟庆磊
关注
专栏目录
数据结构算法刷题笔记——一、极简随记（1.1数组、链表、队列、栈）
weixin_45029825的博客
09-18 228
给长度相等的数组nums1和nums2，重新组织nums1中元素的位置，使得nums1的优势最大化。如果nums1[i] > nums2[i]，就说nums1在索引i上对nums2[i]有优势，优势最大化就是重新组织nums1，尽可能多的让nums1[i] > nums2[i]如果nums2的⻢能赢，那就⽐赛，如果赢不了，那就换个垫底的来送⼈头，保存实⼒。：给一个仅包含字母的字符串，取出字符串中重复的字母，使得每个字母只出现一次，需保证返回结果的字典序最小，要求不能打乱其他字符的相对位置。
数据结构算法刷题笔记——二、2.3 priority_queue
weixin_45029825的博客
09-11 359
优先队列（priority_queue）：本质是heap(堆)，内部实现是一个二叉堆是一个队列，“优先”意指取队首元素时，有一定的选择性，即根据元素的属性选择某一项值最优的出队优先队列其实就是把堆模板化，将所有入队的元素排成具有单调性的一队，方便我们调用优先级队列是一个拥有权值观念的queue。它允许在底端添加元素、在顶端去除元素、删除元素。缺省情况下，优先级队列利用一个大顶堆完成普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除优先队列中，元素被赋予优先级。
6月5日刷题笔记——栈、队列、树
ZD困困困的博客
07-22 252
刷题笔记（数据结构：栈、队列、树）
Leetcode刷题笔记——栈篇
qq_42898642的博客
01-29 992
栈是一种先进后出的数据结构，栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表，这里我不做过多介绍，栈的应用和练习算是面试中的高频考点了，接下来看下我们来看一下Leetcode关于栈的常见面试题题型，每道题都附上了简单明了的python解法，大家重点关注算法思想即可。
代码随想录刷题笔记6——栈与队列
xhj12138的博客
09-06 118
代码随想录的刷题笔记，本章是栈和队列的相关基础操作
数据结构与算法——LeetCode刷题笔记（四）：堆、栈、队列
weixin_42923076的博客
12-26 169
数据结构与算法——LeetCode刷题笔记（四）：堆、栈、队列 好久没更新力扣板块啦！
leecode刷题笔记——数据结构（一）
weixin_46934960的博客
12-15 882
数组 217. Contains Duplicate 存在相同元素 Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct. Example 1: Input: nums = [1,2,3,1] Output: true Example 2: Input: nums = [1,2,3,
leetcode刷题笔记——优先队列priority_queue
weixin_53432918的博客
11-03 267
当需要用自定义的数据类型时才需要传入这三个参数，使用基本数据类型时，只需要传入数据类型，默认是大顶堆基础类型：默认是大顶堆： priority_queue常用函数： push()top()pop()empty()size() （2）结构体的优先级设置 结构体内重载运算符： 重载大于号会编译错误，只需要小于号就能完成比较： 注意事项： 1. 如果结构体内数据较为庞大，建议使用引用来提高效率，比较类参数加上 "const" 和 "&"2. 使用top()函数前，必须使用emp
leecode刷题笔记——数据结构（二）
weixin_46934960的博客
02-02 1287
tree 树 144. Binary Tree Preorder Traversal Given the root of a binary tree, return the preorder traversal of its nodes’ values. Example 1: Input: root = [1,null,2,3] Output: [1,2,3] Example 2: Input: root = [] Output: [] Example 3: Input: root = [1] Out
《剑指Offer》刷题笔记——面试题32-II. 从上到下打印二叉树II
12-22
《剑指Offer》是许多程序员在准备面试时的重要参考资料，其中包含了各种经典的编程问题，旨在提升面试者在算法和数据结构方面的技能。本题“面试题32-II. 从上到下打印二叉树II”是一道关于二叉树层次遍历的问题，...
GitHub一战封神，字节跳动内部顶级数据结构刷题学习笔记根本停不下来（csdn）————程序.pdf
12-01
这些数据结构包括但不限于数组、链表、栈、队列、树、图等，它们为解决复杂问题提供了基础框架。然而，这份笔记特别强调的是排序算法，排序是数据处理中最常见的操作之一，对数据进行排序能够帮助我们更好地分析和...
leetcode刷题笔记——回溯法
md_Ji的博客
02-01 531
leetcode刷题笔记——回溯法 目前完成的回溯法的leetcode算法题序号： 中等：60， 93 困难： 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/reconstruct-itinerary 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 文章目录leetcode刷题笔记——回溯法算法理解一、60题：排列序列1.题干2.思路3.代码二、93题：复原IP地址1.题干2.解题思路3.代码4. 注意点四、1. 题干2. 解
leetcode刷题笔记——广度优先搜索
md_Ji的博客
01-10 710
leetcode刷题笔记——广度优先搜索 目前完成的广度优先搜索相关的leetcode算法题序号： 简单：257 中等：200 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/reconstruct-itinerary 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 文章目录leetcode刷题笔记——广度优先搜索算法理解一、257题：二叉树的所有路径1.题干2.思路3.代码4.总结二、200题：岛屿数量1.题干2.思路3.代码
【数据结构】线段树复杂应用
最新发布
2302_80811345的博客
09-13 1069
随着星际网络的进一步建设和规模的增大，一个新的问题出现在网络工程师面前——地址空间不够用了！原来，星际网络采用了传统的 IPv6 协议，虽然有2128级别的可用地址数量，但面对广袤无垠的宇宙和爆炸式增长的网络用户数，如此庞大的地址空间也面临了用尽的那一天。新的通信协议的研发工作交给了著名的网络科技圣地——西西艾弗星。最终，经过2333年的不懈努力，西西艾弗星的工程师们设计出了一种新的协议——“西西艾弗IP协议”，又称 IPxxaf。在 IPxxaf 协议中，一个地址由n位二进制位组成，其中。
数据结构---非线性--树
2301_80434764的博客
09-13 805
本文将详细介绍树及其变体在计算机科学中的应用及实现。首先，将概述树的基本概念、结构及其实际应用，包括树的表示方法及在各种应用场景中的重要性。接着，深入探讨二叉树的基本概念、特殊类型及其性质，并比较顺序存储和链式存储这两种主要存储结构。 在探讨二叉树的顺序结构及实现时，重点讲解堆的概念与结构，涵盖堆的向上和向下调整算法、建堆的时间复杂度以及堆的插入和删除操作，并讨论堆在排序和Top-K问题中的应用。最后，讨论二叉树的链式结构实现，包括各种遍历方式（如前序、中序、后序和层序遍历）和常见接口。
【数据结构】顺序表的定义和实现
m0_74209563的博客
09-13 578
顺序表是指用的方式实现线性表顺序存储：把的元素存储在的存储单元中，元素之间的关系由存储单元的邻接关系来体现【看到这是否会和我有同样的疑问：顺序表和数组是一样的吗？这个问题可以参考这篇文章的解释】
重头开始嵌入式第三十九天（数据结构 栈）
qq_64792908的博客
09-13 766
栈是一种数据结构，它具有以下特点：1. 只能在一端进行插入和删除操作，这一端被称为栈顶。2. 遵循“后进先出”（Last In First Out，LIFO）的原则。也就是说，最后进入栈的元素最先被弹出。3. 可以用数组或链表来实现。例如，把书一本一本叠放在桌子上，只能从最上面取书或放书，这就类似栈的操作。后放上去的书先被拿走，符合“后进先出”原则。
C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储
BamBoo_Bean的博客
09-13 655
C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储
栈和队列的数据结构详解——清华大学版
"补充算法-数据结构（清华大学版）——栈和队列" 在数据结构中，栈和队列是两种基础且重要的数据结构。栈遵循“后进先出”（LIFO）原则，而队列则遵循“先进先出”（FIFO）原则。在清华大学版的数据结构课程中，这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值