C ++【stack_queue】

已于 2024-07-24 17:34:35 修改
阅读量709 收藏 28
点赞数 24
分类专栏： C++ 文章标签： 开发语言 c++
于 2024-07-24 11:12:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangtianTTT/article/details/140426364
版权

stack_queue

stack

stack的介绍

  1. stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。
  2. stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。
  3. stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：
    empty：判空操作
    back：获取尾部元素操作
    push_back：尾部插入元素操作
    pop_back：尾部删除元素操作
  4. 标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器，默认情况下使用deque。

stack的使用

函数说明借口说明
stack()构造空栈
empty()判空
size()返回stack中元素个数
top()返回栈顶元素的引用
push()将元素val压栈
pop()弹出栈顶元素

stack的模拟实现

从栈的接口中可以看出，栈实际是一种特殊的vector，因此使用vector完全可以模拟实现stack。

#pragma once
#include<vector>
#include<list>
#include<deque>
namespace bit
{
	/*template<class T>
	class stack
	{
	private:
		T* _a;
		int _top;
		int _capacity;
	};*/

	// 设计模式
	// 适配器模式 -- 转换
	// stack<int,vector<int>> st1;
	// stack<int,list<int>> st2;

	template<class T,class Container = deque<T>>
	class stack
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_back();
		}

		size_t size()
		{
			return _con.size();
		}

		bool empty()
		{
			return _con.empty();
		}

		const T& top()
		{
			return _con.back();
		}
	private:
		Container _con;
	};
}

栈的弹出压入序列

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。

  1. 0<=pushV.length == popV.length <=1000
  2. -1000<=pushV[i]<=1000
  3. pushV 的所有数字均不相同

输入：[1,2,3,4,5],[4,5,3,2,1]；返回值：true
输入：[1,2,3,4,5],[4,3,5,1,2]；返回值：false

在这里插入图片描述

queue

queue的介绍

  1. 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
  2. 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。
  3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:
    empty：检测队列是否为空
    size：返回队列中有效元素的个数
    front：返回队头元素的引用
    back：返回队尾元素的引用
    push_back：在队列尾部入队列
    pop_front：在队列头部出队列
  4. 标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器类，则使用标准容器deque。

queue的使用

函数说明借口说明
queue()构造空队列
empty()判空
size()返回队列中有效元素的个数
front()返回队头元素的引用
back()返回队尾元素的引用
push()在队尾将元素val入队列
pop()将队头元素出队列

queue的模拟实现

#pragma once
#include<deque>
namespace bit
{
	template<class T, class Container = deque<T>>
	class queue
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_front();
		}

		size_t size()
		{
			return _con.size();
		}

		bool empty()
		{
			return _con.empty();
		}

		const T& front()
		{
			return _con.front();
		}

		const T& back()
		{
			return _con.back();
		}
	private:
		Container _con;
	};

priority_queue

priority_queue的介绍

  1. 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。
  2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。
  3. 优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。
  4. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：
    empty()：检测容器是否为空
    size()：返回容器中有效元素个数
    front()：返回容器中第一个元素的引用
    push_back()：在容器尾部插入元素
    pop_back()：删除容器尾部元素
  5. 标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指
    定容器类，则使用vector。
  6. 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数
    make_heap、push_heap和pop_heap来自动完成此操作。

priority_queue的使用

优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。注意：
默认情况下priority_queue是大堆。

函数声明接口说明
priority_queue()/priority_queue(first, last)构造一个空的优先级队列
empty()判断优先级队列是否为空
top()返回优先级队列中最大（最小）元素，即堆顶元素
push(x)在优先级队列中插入x
pop()删除优先级队列中最大（最小）元素，即堆顶元素

priority_queue的注意事项

  1. 默认情况下，priority_queue是大堆。
void test_priority_queue()
{
	// 默认大的优先级高，底层是个大根堆
	// 小堆
	//priority_queue<int> pq;
	priority_queue<int,vector<int>,greater<int>> pq;
	pq.push(2);
	pq.push(1);
	pq.push(4);
	pq.push(3);
	while (!pq.empty())
	{
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;


	//仿函数
	vector<int> v = { 1,8,6,7,3, };
	// 升序
	sort(v.begin(), v.end());
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;

	// 降序
	//greater<int> gt;
	//sort(v.begin(), v.end(),gt);
	sort(v.begin(), v.end(), greater<int>());//传的是匿名对象	
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
}
  1. 如果在priority_queue中放自定义类型的数据，用户需要在自定义类型中提供> 或者< 的重载。
class Date
{
public:
	friend ostream& operator<<(ostream& _cout, const Date& d);

	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	bool operator<(const Date& d)const
	{
		return (_year < d._year) ||
			(_year == d._year && _month < d._month) ||
			(_year == d._year && _month == d._month && _day < d._day);
	}
	bool operator>(const Date& d)const
	{
		return (_year > d._year) ||
			(_year == d._year && _month > d._month) ||
			(_year == d._year && _month == d._month && _day > d._day);
	}
	
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}

class GreaterPDate
{
public:
	bool operator()(const Date* p1, const Date* p2)
	{
		return *p1 > *p2;
	}
};
void bittest_priority_queue2()
{
	bit::priority_queue<Date, vector<Date>, bit::greater<Date>> pq;
	Date d1(2024, 6, 8);
	pq.push(d1);
	pq.push(Date(2024, 5, 23));
	pq.push({ 2027,7,20 });//多参数构造函数用花括号括起来支持隐式类型转换，生成临时对象
	while (!pq.empty())
	{
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;

	bit::priority_queue<Date*, vector<Date*>, GreaterPDate> pqptr;
	pqptr.push(new Date(2024, 7, 20));
	pqptr.push(new Date(2024, 7, 24));
	pqptr.push(new Date(2024, 7, 28));
	while (!pqptr.empty())
	{
		cout << *(pqptr.top()) << " ";
		pqptr.pop();
	}
	cout << endl;
}
  1. 仿函数
// 仿函数/函数对象
// 它的对象俺可以像函数一样地去使用
template<class T>
struct Less
{
	bool operator()(const T& x, const T& y)
	{
		return x < y;
	}
};

void test()
{
	Less<int> lessfunc;
	cout << lessfunc(1, 2) << endl;
	cout << lessfunc.operator()(1, 2) << endl;
	cout << Less<int>()(1, 2) << endl;//匿名对象
	cout << Less<int>().operator()(1, 2) << endl;//匿名对象
}

priority_queue的模拟实现

	template<class T>
	struct less
	{
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}
	};

	template<class T>
	struct greater
	{
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};

	//默认大根堆
	template<class T,class Container = vector<T>,class Compare = less<T>>
	class priority_queue
	{
	public:
		void adjust_up(size_t child)
		{
			Compare com;
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				//if (_con[child] > _con[parent])
				//if (_con[parent] < _con[child])
				if (com(_con[parent], _con[child]))//仿函数，对象可以像函数一样去使用
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
					break;
			}
		}

		void push(const T& x)
		{
			_con.push_back(x);
			adjust_up(_con.size() - 1);
		}

		void adjust_down(size_t parent)
		{
			Compare com;
			size_t child = parent * 2 + 1;
			while (child < _con.size())
			{
				//if (child + 1 < _con.size() && _con[child + 1] > _con[child])
				//if (child + 1 < _con.size() && _con[child] < _con[child + 1])
				if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
					++child;
				//if (_con[child] > _con[parent])
				//if (_con[parent] < _con[child])
				if (com(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
					break;
			}
		}

		void pop()
		{
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();
			adjust_down(0);
		}

		bool empty()
		{
			return _con.empty();
		}

		size_t size()
		{
			return _con.size();
		}

		const T& top()
		{
			return _con[0];
		}
	private:
		Container _con;
	};
}

void bittest_priority_queue1()
{
	
	//bit::priority_queue<int, deque<int>> pq;
	//bit::priority_queue<int, vector<int>> pq;
	
	//默认大根堆
	//bit::priority_queue<int> pq;
	//小根堆
	bit::priority_queue<int, vector<int>, bit::greater<int>> pq;

	pq.push(2);
	pq.push(1);
	pq.push(4);
	pq.push(3);
	pq.push(7);
	pq.push(10);
	while (!pq.empty())
	{
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;
}

容器适配器

什么是适配器

适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。

STL标准库中stack和queue的底层结构

虽然stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和队列只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque。

std::
template <class T, class Container = deque<T> > class stack;
template <class T, class Container = deque<T> > class queue;
template <class T, class Container = vector<T>,
  class Compare = less<typename Container::value_type> > class priority_queue;

deque

在这里插入图片描述
deque内部设计
在这里插入图片描述
deque优缺点

优点：头插尾插，效率很好
缺点：1）中间插入删除会很麻烦 2）[]的效率不够极致

反向迭代器模拟实现

迭代器分类

  1. 迭代器性质分类

单向forward_list 单链表 ++
双向 list++/–
随机vector/deque++/–/+/-

  1. 迭代器功能上的分类

正向
反向
const

模拟实现

ReverseIterator.h

#pragma once

// 所有容器的反向迭代器
// 迭代器适配器

namespace bit
{
	//vector<T>::iterator  ->
	//list<T>::iterator  ->
	
	template<class Iterator,class Ref,class Ptr>
	struct ReverseIterator
	{
		typedef ReverseIterator<Iterator, Ref, Ptr> Self;

		Iterator _it;

		ReverseIterator(Iterator it)
			:_it(it)
		{}

		Ref operator*()
		{
			Iterator tmp = _it;
			return *(--tmp);
		}

		Ptr operator->()
		{
			//return _it->;
			//return _it.operator->();
			return &(operator*());
		}

		Self& operator++()
		{
			--_it;
			return *this;
		}

		Self& operator--()
		{
			++_it;
			return *this;
		}

		bool operator!=(const Self& s)
		{
			return _it != s._it;
		}
	};
}

list.h中的反向迭代器

头文件定义：

template<class T>
class list
{
	typedef ListNode<T> Node;
public:
	typedef ListIterator<T, T&, T*> iterator;
	typedef ListIterator<T, const T&, const T*> const_iterator;

	typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
	typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;

	reverse_iterator rbegin()
	{
		return reverse_iterator(end());
	}

	reverse_iterator rend()
	{
		return reverse_iterator(begin());
	}

	iterator begin()
	{
		
		return _head->_next;
	}

	iterator end()
	{
		return _head;
	}
...
}

测试：

void test1()
{
	bit::list<int> lt = { 1,2,3,4,5 };
	bit::list<int>::reverse_iterator rit = lt.rbegin();
	while (rit != lt.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;
	return 0;
}

vector.h中的反向迭代器

头文件定义：

template<class T>
class vector
{
public:
	typedef T* iterator;
	typedef const T* const_iterator;
	typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
	typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;

	reverse_iterator rbegin()
	{
		return reverse_iterator(end());
	}

	reverse_iterator rend()
	{
		return reverse_iterator(begin());
	}

	iterator begin()
	{
		return _start;
	}

	iterator end()
	{
		return _finish;
	}
...
}

测试：

void test2()
{
	bit::vector<int> v = { 1,2,3,4,5 };
	bit::vector<int>::reverse_iterator rit = v.rbegin();
	while (rit != v.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;
	return 0;
}
铃响十分
关注
  • 24
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
link_stack_queue.rar_C 链表_C++链表_链表
09-22
对于C++，还可以利用STL（Standard Template Library）中的`std::stack`和`std::queue`容器，它们提供了更为方便的接口和底层优化，简化了程序员的工作。 在实际应用中，链表、栈和队列广泛用于数据处理、算法实现...
bwlabel_bwlabelc语言_bwlabelC++实现_
09-28
在C++中，可以使用`std::queue`或`std::stack`来辅助实现这些搜索算法。 此外，C++标准库还提供了`std::bitset`，可以用于快速地检查像素的邻接关系，提高效率。同时，`bwlabel`的优化版本可能会涉及到OpenMP等并行...
c++stack_和_queue用法
08-12
### C++ STL中Stack和Queue的使用详解 #### 一、引言 在C++标准模板库(STL)中，提供了许多高效的容器类，其中包括`stack`和`queue`。这两种容器非常适合处理需要先进后出(FILO, First In Last Out)或先进先出(FIFO,...
stack_machine源码
12-01
本文将深入探讨一款名为"stack_machine"的汇编器的C语言源码，旨在帮助读者理解其工作原理和实现细节，提升对底层计算机系统和编译原理的理解。 首先，我们来了解一下汇编器的基本概念。汇编器是编译器的一种特殊...
bfs-dfs.rar_BFS algoritm_BFS+c++
09-22
描述 "bfs ,dfs algoritm in TC" 表明该算法在文本编辑器或编译器如Turbo C中进行了实现，同时也提到了深度优先搜索（DFS）算法。 **BFS算法详解** 广度优先搜索（BFS）是一种用于遍历或搜索树或图的算法。在图中...
第2章 C语言基础知识
m0_70617423的博客
08-14 3081
C语言
python爬虫爬取某图书网页实例
2301_77698138的博客
08-14 4338
下面是通过requests库来对ajax页面进行爬取的案例，与正常页面不同，这里我们获取url的方式也会不同，这里我们通过爬取一个简单的ajax小说页面来为大家讲解。循环遍历URL（这里为大家提供具体url的获取方法，并循环了1至9页的数据为大家做案例），并发送了带有随机User-Agent的GET请求。设置代码来保存图片到以文章名命名的文件中，并将作者、文章名和简介信息写入到"./biquge.txt"文件中。首先进入网页，点击F12打开自定义与控制工具，点击fecth/XHR，此时显示部分为空白。
【C++】链表
qq_38801607的博客
08-22 569
链表是一种常见的动态数据结构，与数组相比，它在插入和删除操作中具有更高的效率。链表的每个元素称为节点（Node），节点包含两个部分：数据域（存储数据）和指针域（指向下一个节点的指针）。链表的最大特点是节点的内存位置不需要连续，可以通过指针来链接在一起。
C++ 重载运算符和重载函数
lly202406的博客
08-25 482
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
c语言用if语句制作点单程序
2301_81968528的博客
08-20 304
printf("数字1代表喝咖啡，数字2代表喝雪碧:");这里的点单程序是用户输入相应的数字自动出来相应的饮品。puts("您要喝的是咖啡");puts("您要喝雪碧");比如输入1是咖啡，输入2是雪碧。c语言里面，if语句的语法是。
初识顺序表---C语言
weixin_74202161的博客
08-23 343
顺序表是一种以数组为基础的结构，对数组进行封装，实现常用的增删改查等操作的。//销毁。
Dijkstra(c++)
weixin_73378557的博客
08-24 491
迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。同时dijkstra算法主要用于解决单源最短路问题（边权为正数），其可以分为两种版本，两种版本各有用处，并不存在好坏之分，接下来我们用n代表点的数量，用m代表边的数量。
C语言01 每日一练01
小蜗的房子
08-24 1233
C语言01 每日一练01
坐牢第三十天（c++）
m0_62828714的博客
08-27 288
提示并输入一个字符串，统计该字符串中字母个数、数字个数、空格个数、其他字符的个数 效果图：
C++：list篇
最新发布
2301_80894970的博客
08-27 596
我们可以看到，当erase后如果在对it迭代器进行操作，vs则会进行强制检查(根据编译环境不同，处理环境也不相同),则不允许再继续使用,如果想继续使用的话，C++同样也给出了方案，可以看到erase会返回一个迭代器，而返回的迭代器就是下一个链表的位置。那么从上面的begin与end可以看出，使用迭代器遍历list，仅仅只需要解引用迭代器以及++迭代器就能取得我们想要的值与让迭代器走向下一个节点，那么有没有想过一个问题，list的迭代器与vector这种类似数组的迭代器底层是否是一样的呢？
【C++】类与对象
2401_82855612的博客
08-24 346
C++编译器给每个非静态的成员函数增加了一个隐藏的指针参数即this指针让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只需要计算成员变量的大小（注意内存对齐），不需要计算成员函数的大小，无论定义多少对象，成员函数就只有一个是公用的. 编译器给了空类一个字节来唯一标识这个类的对象。如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整 体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
c++每日练习记录4-（递归思想）
qq_33867768的博客
08-23 174
递归的思想：反向思考一个问题，由简单推广到复杂，找到规律方程。类似于解决高次的微分方程问题。（暂时不能很好理解可以看。利用利用两个新的指针，一个用于保存输出的初始节点，另外一个用于地址的迭代指向。
C++：类和对象（二）
Harper.Lee的博客
08-27 518
本篇博客介绍内容：构造函数、析构函数、拷贝构造函数、运算符重载和赋值运算符重载，以及一些细节例如：深浅拷贝、传值返回与传引用返回、传值传参与传引用传参等！
【C++ Primer Plus习题】5.1
qq_74047911的博客
08-25 171
【C++ Primer Plus习题】5.1
Nirvana 15:38:49 #include <stdio.h> #include <conio.h> #include <stdbool.h> #define MAX_QUEUE_SIZE 1000 void main() { char queue[MAX_QUEUE_SIZE]; int front=0,rear=0; char ch; ch=getchar(); while(ch!='#') { queue[rear]=ch; rear++; ch=getchar(); } while(front<rear) { printf("%c",queue[front]); front++; } printf("\n"); getch(); } Nirvana 15:39:07 #include <stdio.h>#include <conio.h>#define MAX_STACK_MAX 1000void main(){ char stack[MAX_STACK_MAX]; int top=0,i; char ch;ch=getchar(); while (ch!='!'&&top<MAX_STACK_MAX) { switch(ch) { case'#': if(top>0) top--; break; case'@': top=0; break; default: stack[top]=ch; top++; break; } ch=getchar(); } for(i=0;i<top;i++) printf("%c",stack[i]); printf("\n"); getch();}将这两段代码合为一段代码
06-08
以下是将两段代码合并后的代码： ```c #include <stdio.h> #include <conio.h> #include <stdbool.h> #define MAX_QUEUE_SIZE 1000 #define MAX_STACK_MAX 1000 void main() { char queue[MAX_QUEUE_SIZE]; int front = 0, rear = 0; char stack[MAX_STACK_MAX]; int top = 0, i; char ch; ch = getchar(); while (ch != '#') { queue[rear] = ch; rear++; ch = getchar(); } ch = getchar(); while (ch != '!' && top < MAX_STACK_MAX) { switch(ch) { case '#': if (top > 0) { top--; } break; case '@': top = 0; break; default: stack[top] = ch; top++; break; } ch = getchar(); } printf("Queue output: "); while (front < rear) { printf("%c", queue[front]); front++; } printf("\n"); printf("Stack output: "); for (i = 0; i < top; i++) { printf("%c", stack[i]); } printf("\n"); getch(); } ``` 这个合并后的代码可以分别读入字符到队列和栈中，并输出它们的内容。其中，遇到 `#` 时队列弹出元素，遇到 `@` 时栈清空。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值