栈和队列

最新推荐文章于 2023-10-28 19:20:29 发布
最新推荐文章于 2023-10-28 19:20:29 发布
阅读量197 收藏
点赞数
分类专栏： 数据结构和算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/msdnhehe/article/details/52745325
版权

1.栈的特点：先进后出，由栈顶指针来控制数据的存储。

2.队列的特点：先进先出。

3.链表主要的优点就是可以方便的进行插入、删除操作，利用这一优点，可以在游戏设计过程中方便地管理大量的数据。

4.单向线性表的链式存储：有一个数据，一个后指针。最后一个元素的Next指针为NULL.

5.栈是一种只允许在一端进行插入和删除的线性表，它是一种操作受限的线性表。

6.在表中只允许进行插入和删除的一端称为栈顶，另一端称为栈底。

7.栈的插入操作通常称为入栈或进栈，而栈的删除操作则称为出栈或退栈。当栈中没有数据元素时，称为空栈。

8.顺序栈类的代码：

   #ifndef CStack_H_

#define CStack_H_

#pragma once

 

template<typename T> class CStack

{

protected:

const int m_iLength;

T * m_pArray; //存储数据的数组

int m_iStackTop; //栈顶元素标号，描述下一个可入栈位置

public:

CStack(int iLength);

~CStack(void);

//栈的基本操作：显示栈内元素、判定栈是否为满、

//       是否为空、入(压)栈、出栈

protected:

bool isFull();

bool isEmpty();

public:

void showStack();

void pushStack(T _data);

T popStack();

};

#endif

#include "Utility.h"

#include "Stack.h"

 

 

template<typename T>CStack<T>::CStack(int iLength):

m_iLength(iLength)

{

m_pArray = new T[m_iLength];

memset(m_pArray,0,m_iLength*sizeof(int));

m_iStackTop = 0;

}

 

template<typename T>CStack<T>::~CStack(void)

{

Safe_Delete_Array(m_pArray);

}

 

template<typename T>void CStack<T>::showStack()

{

if(isEmpty())

{

cout<<"空栈！！！"<<endl;

return;

}

cout<<"栈内元素为："<<endl;

for( int i = m_iStackTop-1 ; i >= 0 ; --i )

cout<<"stack["<<i<<"]="<<m_pArray[i]<<endl;

}

 

template<typename T>bool CStack<T>::isFull()

{

if(m_iStackTop == m_iLength)

return true;

return false;

}

 

template<typename T>bool CStack<T>::isEmpty()

{

if(m_iStackTop == 0)

return true;

return false;

}

 

template<typename T>void CStack<T>::pushStack(T _data)

{

if(!isFull())

m_pArray[m_iStackTop++] = _data;

}

 

template<typename T>T CStack<T>::popStack()

{

T result = 0;

if(!isEmpty())

{

result = m_pArray[--m_iStackTop];

m_pArray[m_iStackTop] = 0;

}

return result;

}

9.链表操作：

  #include "Utility.h"

 

//----节点的描述方式：通过结构体实现----

typedef struct stNode

{

int iValue; //节点数据域

stNode * pNext; //节点的指针域

}NODE, *LPNODE;

 

LPNODE pHead = NULL; //链表的头节点

LPNODE pTail = NULL; //链表的尾节点

 

 

//---显示链表中的所有元素---

void showList()

{

if(pHead == NULL)

cout<<"链表为空......"<<endl;

 

LPNODE pTemp = pHead;

while (pTemp) //通过链表头节点遍历链表所有元素

{

cout<<pTemp->iValue<<endl;

pTemp = pTemp->pNext; //指针下移

}

}

 

//----在链表头插入数据----

void insertNodeAtFront( int iData )

{

if(pHead == NULL) //链表中无节点

{

LPNODE pNode = new NODE;

pNode->iValue = iData;

pNode->pNext = NULL;

pHead = pNode;

pTail = pNode;

}

else //链表中已经存在节点

{

LPNODE pNode = new NODE;

pNode->iValue = iData;

pNode->pNext = pHead;

pHead = pNode;

}

}

//----在链表尾部插入数据----

void insertNodeAtBack( int iData )

{

if(pHead == NULL)

{

LPNODE pNode = new NODE;

pNode->iValue = iData;

pNode->pNext = NULL;

pHead = pNode;

pTail = pNode;

}

else

{

//1、创建该节点

LPNODE pNode = new NODE;

pNode->iValue = iData;

pNode->pNext = NULL;

 

//2、将该节点链接入链表

pTail->pNext = pNode;

pTail = pNode;

}

}

 

 

//----在链表中删除头节点元素----

int deleteNodeAtFront()

{

//链表中仅剩1个节点

if( pHead == pTail )

{

Safe_Delete(pHead);

pTail = NULL;

return 0;

}

 

LPNODE pTemp = pHead;

pHead = pHead->pNext;

int iResult = pTemp->iValue;

Safe_Delete(pTemp);

return iResult;

}

 

//----在链表中删除尾节点元素----

int deleteNodeAtBack()

{

//链表中仅剩1个节点

if( pHead == pTail )

{

Safe_Delete(pTail);

pHead = NULL;

return 0;

}

 

//让pDeleteNode指向尾节点

LPNODE pDeleteNode = pTail;

//通过遍历找到尾节点的前一个节点

LPNODE pTempNode = pHead;

while(pTempNode)

{

if(pTempNode->pNext == pTail)

{

pTail = pTempNode;

pTail->pNext = NULL;

break;

}

else

pTempNode = pTempNode->pNext;

}

 

//删除节点

int iResult = pDeleteNode->iValue;

Safe_Delete(pDeleteNode);

 

return iResult;

}

 

 

-----2015.6.4----在链表中删除指定元素----------

//int deleteNode( int iData )

//{

//LPNODE pTemp = pHead;

//int iResult = 0;

//while(pTemp)

//{

////单独判定头节点是否为我们要删除的节点

//if(pTemp->iValue == iData)

//{

//LPNODE pDeleteNode = pTemp;

//pTemp = pTemp->pNext;

//pHead = pHead->pNext;

//iResult = pDeleteNode->iValue;

//Safe_Delete(pDeleteNode);

//continue;

//}

//else//头节点不是我们要删除的节点

//{

//if(pTemp->pNext)

//{

//if( pTemp->pNext->iValue == iData )

//{

//LPNODE pDeleteNode = pTemp->pNext;

//pTemp->pNext = pDeleteNode->pNext;

//

//iResult = pDeleteNode->iValue;

//Safe_Delete(pDeleteNode);

//}

//}

//pTemp = pTemp->pNext;

//}

//}

//

//return iResult;

//}

 

 

void deleteNode(int iData)

{

if(!pHead)

return;

 

//定义一对儿 “伴生” 指针

LPNODE pPrevious = pHead;

LPNODE pLast  = pHead->pNext;

 

while( pLast )

{

//1.头节点是否为要删除的节点

if(pPrevious->iValue == iData)

{

pHead = pHead->pNext;

LPNODE pDeleteNode = pPrevious;

pPrevious = pPrevious->pNext;

pLast = pLast->pNext;

 

Safe_Delete(pDeleteNode);

continue;

}

else  

{

if(pLast->iValue == iData)

{

if( pLast == pTail )

{

pPrevious->pNext = NULL;

Safe_Delete(pLast);

 

pTail = pPrevious;

break;

}

pPrevious->pNext = pLast->pNext;

LPNODE pDeleteNode = pLast;

pLast = pLast->pNext;

Safe_Delete(pDeleteNode);

continue;

}

else

{

pPrevious = pPrevious->pNext;

pLast = pLast->pNext;

}

}

}

}

void main()

{

//showList();

//cout<<"--------在链表头部插入数据--------"<<endl;

//insertNodeAtFront(5);

//insertNodeAtFront(10);

//showList();

//cout<<"--------在链表尾部插入数据--------"<<endl;

//insertNodeAtBack(101);

//showList();

//cout<<"--------在链表头部删除数据--------"<<endl;

//cout<<"删除的元素值为："<<deleteNodeAtFront()<<endl;

//showList();

//cout<<"--------在链表尾部删除数据--------"<<endl;

//cout<<"删除的元素值为："<<deleteNodeAtBack()<<endl;

//showList();

//cout<<"--------在链表尾部删除数据--------"<<endl;

//cout<<"删除的元素值为："<<deleteNodeAtFront()<<endl;

//showList();

//------------2015.6.4--------------

//insertNodeAtBack(10);

//insertNodeAtBack(20);

//insertNodeAtBack(30);

//insertNodeAtBack(10);

//insertNodeAtBack(40);

//showList();

//cout<<"----------删除元素值为30的节点----------"<<endl;

//deleteNode(30);

//showList();

cout<<"----------删除元素值为10的节点----------"<<endl;

deleteNode(40);

showList();

system("pause");

}

10.数据结构队列：

   #include "Utility.h"

/*

队列的作用：

   在Windows编程中，所有的"消息"都是靠"队列"来存储

并逐个处理

*/

//--------顺序队列--------

class COrderQueue

{

protected:

int m_iQueue[5];

int m_iHeadIndex;

int m_iTailIndex; //最后一个有效元素的下标

public:

COrderQueue()

{

memset(m_iQueue,0,5*sizeof(int));

m_iHeadIndex = m_iTailIndex = 0;

}

void showQueue();

void push_back(int _data);

int  pop_front();

};

void COrderQueue::showQueue()

{

if( m_iQueue[m_iHeadIndex] == 0 )

{

cout<<"空队列"<<endl;

return ;

}

for(int i = m_iHeadIndex ; i <= m_iTailIndex ; ++i)

{

cout<<"队列["<<i<<"] = "<<m_iQueue[i]<<endl;

}

}

void COrderQueue::push_back(int _data)

{

//队列已满

if( m_iTailIndex == 5-1 )

{

cout<<"队列已满，无法插入数据"<<endl;

return;

}

//队列为空

if( m_iQueue[m_iHeadIndex] == 0 )

{

m_iQueue[m_iHeadIndex] = _data;

}

else

{

m_iQueue[++m_iTailIndex] = _data;

}

}

int  COrderQueue::pop_front()

{

//队列为空

if( m_iQueue[m_iHeadIndex] == 0 )

{

cout<<"队列为空，无法出队列"<<endl;

return 0;

}

 

//队列不为空，记录出队列的数据

int iRemove = m_iQueue[m_iHeadIndex];

 

//元素移动

for(int i = m_iHeadIndex + 1 ; i <= m_iTailIndex ; ++i )

{

m_iQueue[i-1] = m_iQueue[i];

}

 

//原始队列最后一个有效数据赋值为0，并前移动m_iTailIndex

m_iQueue[m_iTailIndex--] = 0;

 

return iRemove;

}

 

 

//--------链式队列--------

typedef struct stNode

{

int iData;

stNode * pNext;

}NODE,*LPNODE;

class CListQueue

{

protected:

LPNODE m_pHead; //头

LPNODE m_pTail; //尾

public:

CListQueue(){m_pHead = m_pTail = NULL;}

void showQueue();

void push_back(int _data);

LPNODE pop_front();

};

 

void CListQueue::showQueue()

{

if(!m_pHead)

{

cout<<"队列为空，无法显示"<<endl;

return;

}

 

LPNODE pTemp = m_pHead;

while(pTemp)

{

cout<<pTemp->iData<<endl;

pTemp = pTemp->pNext;

}

}

void CListQueue::push_back(int _data)

{

LPNODE pNode = new NODE();

pNode->iData = _data;

pNode->pNext = NULL;

 

//空队列

if(!m_pHead)

{

m_pHead = pNode;

m_pTail = pNode;

}

else

{

m_pTail->pNext = pNode;

m_pTail = pNode;

}

}

LPNODE CListQueue::pop_front()

{

//队列为空

if(!m_pHead)

{

cout<<"队列为空，无法出队列"<<endl;

return NULL;

}

 

LPNODE pRemove = NULL;

 

如果队列仅有1个元素

//if( m_pHead == m_pTail )

//{

//pRemove = m_pHead;

//m_pHead = m_pHead->pNext;

//m_pTail = m_pTail->pNext;

 

//pRemove->pNext = NULL;

//}

//else//至少有2个元素

//{

pRemove = m_pHead;

m_pHead = m_pHead->pNext;

pRemove->pNext = NULL;

//}

 

//仅有1个元素

if( pRemove == m_pTail )

{

m_pTail = NULL;

}

 

return pRemove;

}

 

 

 

void main()

{

//--------顺序队列的调用--------

COrderQueue queue;

 

queue.push_back( 5);

queue.push_back(10);

queue.push_back(15);

queue.push_back(20);

queue.push_back(25);

 

queue.showQueue();

 

cout<<"出队列元素为："<<queue.pop_front()<<endl;

queue.showQueue();

 

//--------链式队列的调用--------

cout<<"--------链式队列的调用--------"<<endl;

CListQueue listQueue;

listQueue.push_back( 5);

listQueue.push_back(10);

listQueue.push_back(15);

listQueue.showQueue();

 

cout<<"出队列的元素为："<<listQueue.pop_front()->iData<<endl;

listQueue.showQueue();

 

cout<<"出队列的元素为："<<listQueue.pop_front()->iData<<endl;

listQueue.showQueue();

 

cout<<"出队列的元素为："<<listQueue.pop_front()->iData<<endl;

listQueue.showQueue();

 

system("pause");

}

11.链栈：

   #include "Utility.h"

 

template <typename T> class NODE

{

public:

T iData;

NODE<T> * pNext;

};

 

template <typename T> class CStack

{

protected:

NODE<T> * pHead;

NODE<T> * pTail;

public:

CStack();

void showStack(); //显示栈元素

void push_Stack(T _data); //入栈

NODE<T> * pop_Stack(); //出栈

};

 

template<typename T>

CStack<T>::CStack()

{

pHead = NULL;

pTail = NULL;

}

 

template<typename T>

void CStack<T>::showStack()

{

if(pHead == NULL)

cout<<"栈为空"<<endl;

 

NODE<T> * pTemp = pHead;

while(pTemp)

{

cout<<pTemp->iData<<endl;

pTemp = pTemp->pNext;

}

}

 

template<typename T>

void CStack<T>::push_Stack(T _data)

{

NODE<T> *  pNode = new NODE<T>();

pNode->iData = _data;

pNode->pNext = NULL;

if(pHead == NULL) //当链栈为空时

{

pHead = pNode;

pTail = pNode;

}

else //链栈不为空

{

pNode->pNext = pHead;

pHead = pNode;

}

}

 

template<typename T>

NODE<T> *  CStack<T>::pop_Stack()

{

//如果栈内没有元素

if(pHead == NULL)

{

cout<<"栈内无元素，无法出栈"<<endl;

return NULL;

}

 

NODE<T> *  pRemoveNode = NULL;

 

//如果栈内有且仅有1个元素

if(pHead->pNext == NULL)

{

pRemoveNode = pHead;

pHead = pTail = NULL;

return pRemoveNode;

}

 

//栈内具有多个元素

pRemoveNode = pHead;

pHead = pHead->pNext;

pRemoveNode->pNext = NULL;

return pRemoveNode;

}

 

 

/*

struct就是C语言时代的"类"

class 是C++语言时代的"类"

联系：都可以带构造函数，

区别是：struct默认访问权限是：public

    class默认访问权限是：private

*/

struct stPlayer

{

string name;

int iLevel;

 

//结构体的构造函数

stPlayer(){ name = "" ; iLevel = 1;}

stPlayer(string _name,int _level)

{

name = _name;

iLevel = _level;

}

};

 

 

void main()

{

//--------int型链栈--------

cout<<"--------int型链栈--------"<<endl;

CStack<int> intStack;

 

intStack.push_Stack(5);

intStack.push_Stack(10);

intStack.push_Stack(15);

 

intStack.showStack();

 

NODE<int> * pRemoveNode = intStack.pop_Stack();

cout<<"出栈元素为："<<pRemoveNode->iData<<endl;

intStack.showStack();

 

pRemoveNode = intStack.pop_Stack();

cout<<"出栈元素为："<<pRemoveNode->iData<<endl;

intStack.showStack();

 

pRemoveNode = intStack.pop_Stack();

cout<<"出栈元素为："<<pRemoveNode->iData<<endl;

intStack.showStack();

 

//--------float型链栈--------

cout<<"--------float型链栈--------"<<endl;

CStack<float> floatStack;

floatStack.push_Stack(1.5f);

floatStack.push_Stack(3.5f);

floatStack.push_Stack(5.5f);

 

floatStack.showStack();

 

NODE<float> * pRemove = floatStack.pop_Stack();

cout<<"出栈元素为："<<pRemove->iData<<endl;

floatStack.showStack();

 

pRemove = floatStack.pop_Stack();

cout<<"出栈元素为："<<pRemove->iData<<endl;

floatStack.showStack();

 

pRemove = floatStack.pop_Stack();

cout<<"出栈元素为："<<pRemove->iData<<endl;

floatStack.showStack();

 

//--------结构体类型的链栈----------

CStack<stPlayer> playerStack;

playerStack.push_Stack(stPlayer());

playerStack.push_Stack(stPlayer("xiaohong",1));

system("pause");

}

msdnhehe
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ stack用法 入门必看 超详细
weixin_52115456的博客
10-30 1万+
stack 容器名如：储存int型数据的栈 stack s;储存double型数据的栈 stack s;储存string型数据的栈 stack s;储存结构体或者类的栈 stack s;当然也可以定义stack数组：储存int型数据的栈 stack s[n];储存double型数据的栈 stack s[n;等等，n为数组的大小。
C/C++ stack栈的理解以及使用
青春无问西东 岁月自成芳华
08-30 1万+
今天我们来一起深入学习一下非常重要以及基础的数据结构——栈(stack) 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。
IAR 中设置 CSTACK HEAP作用
zjp1234zjp的博客
04-20 1726
1. CSTACK：限制函数中定义数组的最大值，否则进入HardFault_Hander 具体内存使用情况，可在仿真时查看。 进入调试界面后，通过View->Stack打开Stack观察窗口，程序运行一段时间后，手动或由断点让程序暂停运行，stack窗口将显示应用程序运行到当前位置的实际堆栈使用情况 2. HEAP：限制动态分配内存（C函数库中的malloc）的大小，不用可以设置为0 注意： 本人使用到了CJson 库函数，在CJson内部是有malloc函数的，所以空间应尽可..
【C语言】 “函数指针”和“指针函数” 用法和详解（太细了！！！）菜鸟级教程
huzhuohuan的博客
10-28 431
（1）堆和栈是 C 语言中两种不同的内存区域，用途和管理方式不同。（2）堆用于动态分配和管理数据，需要手动分配和释放。（3）栈用于函数调用和局部变量，内存分配和释放是自动的。（4）堆和栈在内存管理方面有不同的用途和约束，程序员应根据需求合理选择它们。（5）在 C 语言中，需要特别注意内存管理，以避免内存泄漏和悬挂指针等问题。
栈（stack）入门详解之C语言版
sunnyoldboy博客
11-12 7679
栈(Stack)：是一种受限的线性表，即限制在表的一端进行插入和删除操作。栈也称为后进先出LIFO (Last In First Out)或先进后出FILO (First In Last Out)线性表。 栈顶(top)：允许进行插入、删除操作的一端称为栈的栈顶(top)，也称为表尾。 栈底（bottom）：固定不动的一端，称为栈底（bottom），也称为表头。
数据结构栈和队列试题及答案
11-26
队列和栈都是运算受限的线性表，只允许在表的一端进行特定的插入和删除操作，该说法正确。 18. **栈和队列的基本属性** 栈和队列都是线性表，但它们分别采用了LIFO和FIFO的规则来约束插入和删除操作，该说法正确...
利用栈和队列实现迷宫
06-20
"利用栈和队列实现迷宫" 通过栈和队列两种不同的方法来实现迷宫问题。队列方法求出的迷宫路径是最短路径。迷宫问题是指在一个迷宫中找到从起点到终点的路径。这里我们使用栈和队列两种数据结构来解决这个问题。 栈...
zhanheduilie.rar_栈和队列
09-24
栈和队列是计算机科学中基础且重要的数据结构，它们在程序设计中有着广泛的应用。在本资料"zhanheduilie.ppt"中，详细讲述了这两种数据结构的原理、特性以及实际应用。 栈（Stack）是一种后进先出（LIFO, Last In ...
Python实现栈和队列的简单操作方法示例
09-18
本篇文章将深入探讨Python中如何实现栈（Stack）和队列（Queue）这两种基础数据结构。 栈是一种后进先出（Last In, First Out, LIFO）的数据结构，常用于临时存储和快速访问数据。在Python中，由于列表（List）的...
栈和队列笔记包括栈和队列的定义、顺序栈出入栈、链栈的出入栈操作、顺序队列基本操作、链式队列基本操作等
最新发布
04-03
### 栈和队列知识点详解 #### 一、栈的定义 栈是一种特殊的线性数据结构，其特点是只允许在一端进行数据的插入和删除操作，遵循“先进后出”(First In Last Out, FILO)的原则。在这个数据结构中，最新加入的数据...
graylog 后起之秀，可以替代elk的轻量化工具
02-09
Docker默认使用了json-file driver作为log driver，因此日志是存储在一个json.log的本地文件中的。而gelf则是本文需要使用的log driver。 当容器多了，或者是采用类似swarm集群部署Docker的时候，各种日志分散存在各个json.log文件中，当查找问题或者进行相关统计的时候，分散的日志对我们来说是非常不友好的。我们需要一个能够集中管理Docker日志的工具
向量6（继承）栈操作 C++
笔记
06-21 165
根据栈指针的方式操作。
IAR编译cstack错误及解决办法
一颗偏执的心
05-25 5214
IAR编译cstack错误： Error[e16]: Segment CSTACK (size: 0x20 align: 0x1) is too long for segment definition. At least 0x6 more bytes needed. The problem occurred while processing the segment placement com
抗疫先锋 | CStack 您身边的GPU云桌面专家
07-02 9373
2020年，受到新型冠状病毒的影响，无数云计算企业扮演了关键的抗击疫情技术角色，以「云+产业」的模式，在疫情监控、远程医疗、协同办公、在线教育等领域，帮助企业上云、在线提供服务。上海酷栈...
stm32 堆和栈(stm32 Heap & Stack)【worldsing笔记】
weixin_30340775的博客
11-06 1785
关于堆和栈已经是程序员的一个月经话题，大部分有是基于os层来聊的。 那么，在赤裸裸的单片机下的堆和栈是什么样的分布呢？以下是网摘： 刚接手STM32时，你只编写一个 int main() { while(1); } BUILD://Program Size: Code=340 RO-data=252 RW-data=0 ZI-data=1632 编译后，就会...
实现CStack类遇到的问题
weixin_34320724的博客
04-18 287
2019独角兽企业重金招聘Python工程师标准>>> ...
IAR调试时出现“The stack 'CSTACK' is filled to 100%”问题及解决办法
hitxiaya的专栏
05-10 1万+
option->debugger里有个download，里面有个use flash loader选项，勾选上问题就解决了。 如下图所示：
栈(stack) C语言实现 详解
热门推荐
过道
05-08 10万+
栈是数据结构中较为简单的结构体,是一种操作收到限制的线性表.但简单不代表没用,毕竟数组还贼简单呢.谁敢说数组没用?栈栈的理论 栈是一个先进后出的结构,类似于堆盘子,先放到地上的盘子最后被取走(默认只能取走一个盘子) 栈其实就是操作受限的线性表,只有一个口,每一次操作时,这个口可以当出口也可以当入口. 例如:水桶,注入水时,水桶的头当做入口,倒水时,水桶的头当做出口 栈的图解.在图解之前,先举一个例...
The stack 'CSTACK' is filled to 100% (4096 bytes used out of 4096) 错误解决
03-25 7713
今天调个程序，出现这个错误 The stack 'CSTACK' is filled to 100% (4096 bytes used out of 4096)  一开始以为堆栈设小了，一直增大堆栈大小也没用。 纠结了好久。 后来在网上搜到一段有用的资料。。。 关键字 总之这是一个数组越界问题，只要找出越界的数组，然后问题就解决了。。 所谓堆栈检查就是在初始化的时候把
栈和队列基础与实现
"本资源是关于课堂练习，主要涉及栈和队列这两种数据结构，特别是循环队列的入队和出队算法。同时，提供了链式队列的定义以及栈...通过链式队列和顺序栈的示例，学生可以深入理解这两种数据结构的工作原理和实现细节。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值