27 map和set封装

已于 2024-06-20 09:41:10 修改
阅读量642 收藏 14
点赞数 11
分类专栏： 03 深入理解 c++ 文章标签： c++
于 2024-06-20 01:12:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43422358/article/details/139816046
版权

map和set可以采用两套红黑树实现，也可以用同一个红黑树，就需要对前面的结构进行修改
迭代器的好处是可以方便遍历，是数据结构的底层实现与用户透明。如果想要给红黑树增加迭代器，需要考虑以前问题：

  • begin()和end()

stl明确规定，begin和edn代表的是一段前闭后开的区间，而对红黑树进行中序遍历后，可以得到一个有序序列，因此：begin可以放在红黑树中最小节点（即最左侧节点）的位置，end放在最大结点（最右侧节点）的下一个位置，关键是最大节点的下一个位置在哪？如果给成nullptr，end的–操作要能找到最后一个元素的位置，最好的方式是将end放在头节点的位置

在这里插入图片描述

迭代器结构

在红黑树中提供一个迭代器类，提供基本的*，->，++，–等运算符重载。变量时一个节点指针，用节点来初始化迭代器
在这里插入图片描述
加入上面构造的好处
固定的普通迭代器初始化这个迭代器类，参数模板都用T，如果T传入的是普通迭代器，就是拷贝构造，如果是cosnt迭代器，就支持用普通迭代器隐式转换常量迭代器，保证set的key不能修改

++和–

迭代器的++是按中序遍历的顺序找到下一个元素，遵循中序的原则。规则是：当前节点判断它的右节点有没有节点，如果有，就找到右子树中最小的，也就是最左的结点。如果是空，就看它是双亲的左还是右，如果是左，按中序原则就到它的父亲位置，如果是右，说明这颗子树遍历完毕，向上重复直到找到cur是par的左节点的时候，如果到end的位置就结束

self& operator++()
{
	//1.右不为空,找右树最左节点
	if (_node->_right != nullptr)
	{
		node* subleft = _node->_right;
		while (subleft->_left)
		{
			subleft = subleft->_left;
		}

		_node = subleft;
	}
	else
	{
		//2.右为空,沿着路径找孩子是父亲左的祖先
		node* cur = _node;
		node* parent = cur->_parent;
		while (parent && parent->_right == cur)
		{
			cur = parent;
			parent = parent->_parent;
		}

		_node = parent;
	}

	return *this;
}

–和++的操作是镜像的，左为空，找是右子树的结点

self& operator--()
{
	//1.左不为空,找左树最右节点
	if (_node->_left != nullptr)
	{
		node* subright = _node->_left;
		while (subright->_right)
		{
			subright = subright->_right;
		}

		_node = subright;
	}
	else
	{
		//2.左为空,沿着路径找孩子是父亲右的祖先
		node* cur = _node;
		node* parent = cur->_parent;
		while (parent && parent->_left == cur)
		{
			cur = parent;
			parent = parent->_parent;
		}

		_node = parent;
	}

	return *this;
}

全

enum color
{
	RED,
	BLACK
};
template <class T>
struct TreeNode
{
	struct TreeNode<T>* _parent;
	struct TreeNode<T>* _left;
	struct TreeNode<T>* _right;
	T _data;
	color _col;

	TreeNode(T data)
		:_parent(nullptr), _left(nullptr), _right(nullptr)
		, _data(data), _col(RED)
	{}
};
template <class T, class Ref, class Ptr>
struct __RBTreeIterator
{
	typedef TreeNode<T> node;
	typedef __RBTreeIterator<T, Ref, Ptr> self;
	node* _node;
	__RBTreeIterator(node* cur)
		:_node(cur)
	{}
	//普通迭代器，当迭代器是普通时是拷贝构造，是const迭代器时支持普通转换const
	__RBTreeIterator(const __RBTreeIterator<T, T&, T*>& it)
	{
		_node = it._node;
	}

	Ref operator*()
	{
		return _node->_data;
	}

	Ptr operator->()
	{
		return &_node->_data;
	}

	bool operator!=(const self& x)
	{
		return x._node != _node;
	}

	self& operator++()
	{
		//1.右不为空,找右树最左节点
		if (_node->_right != nullptr)
		{
			node* subleft = _node->_right;
			while (subleft->_left)
			{
				subleft = subleft->_left;
			}

			_node = subleft;
		}
		else
		{
			//2.右为空,沿着路径找孩子是父亲左的祖先
			node* cur = _node;
			node* parent = cur->_parent;
			while (parent && parent->_right == cur)
			{
				cur = parent;
				parent = parent->_parent;
			}

			_node = parent;
		}

		return *this;
	}

	self& operator--()
	{
		//1.左不为空,找左树最右节点
		if (_node->_left != nullptr)
		{
			node* subright = _node->_left;
			while (subright->_right)
			{
				subright = subright->_right;
			}

			_node = subright;
		}
		else
		{
			//2.左为空,沿着路径找孩子是父亲右的祖先
			node* cur = _node;
			node* parent = cur->_parent;
			while (parent && parent->_left == cur)
			{
				cur = parent;
				parent = parent->_parent;
			}

			_node = parent;
		}

		return *this;
	}

};

begin和end

红黑树提供begin和end功能，begin返回最左的元素，也就是最小的值。end返回空迭代器

typedef __RBTreeIterator<T, T&, T*> iterator;
typedef __RBTreeIterator<T, const T&, const T*> const_iterator;

iterator begin()
{
	//中序第一个,最左节点
	node* cur = _root;
	while (cur && cur->_left)
	{
		cur = cur->_left;
	}
	return iterator(cur);
}

const_iterator begin() const
{
	//中序第一个,最左节点
	node* cur = _root;
	while (cur && cur->_left)
	{
		cur = cur->_left;
	}
	return const_iterator(cur);
}

iterator end()
{
	return iterator(nullptr);
}

const_iterator end() const
{
	return const_iterator(nullptr);
}

insert返回值

insert的返回值返回pair，第一个参数是iterator，第二个参数插入成功或失败，如果插入成功，就返回插入位置，插入失败，就返回已经存在的数据位置

insert比较

set是比较key的值，而map传入的值是pair，pair本身的比较规则是先比较first，first相等比较second。而我们想要的是只比较first，所以要统一两个的比较方法
在这里插入图片描述
在这里插入图片描述

模板里传入一个KeyOfT，是一个仿函数，根据不同的T的类型，取到set和map用于比较的元素

std::pair<iterator, bool> insert(const T& data)
{
	KeyOfT kot;
	if (_root == nullptr)
	{
		_root = new node(data);
		_root->_col = BLACK;
		return std::make_pair(iterator(_root), true);
	}

	node* parent = nullptr;
	node* cur = _root;
	while (cur)
	{
		parent = cur;
		if (kot(data) < kot(cur->_data))
		{
			cur = cur->_left;
		}
		else if (kot(data) > kot(cur->_data))
		{
			cur = cur->_right;
		}
		else
		{
			return std::make_pair(iterator(cur), false);;
		}
	}
	//插入
	cur = new node(data);
	node* newnode = cur;
	cur->_parent = parent;
	if (data < parent->_data)
	{
		parent->_left = cur;
	}
	else
	{
		parent->_right = cur;
	}

	//父节点是红色调整
	while (parent && parent->_col == RED)
	{
		node* gdparent = parent->_parent;
		node* uncle;

		if (gdparent->_left == parent)
		{
			uncle = gdparent->_right;
			//第一种情况 叔叔节点是红色,变色
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				gdparent->_col = RED;
			}
			//第二种情况 分左右
			//     g
			//  par  un
			// cur
			else
			{
				if (cur == parent->_left)
				{
					RotateRight(gdparent);
					parent->_col = BLACK;
					gdparent->_col = RED;
				}
				//     g
				//  par  un
				//    cur
				else
				{
					RotateLeft(parent);
					RotateRight(gdparent);
					cur->_col = BLACK;
					parent->_col = RED;
					gdparent->_col = RED;
				}

				break;
			}
		}
		else
		{
			uncle = gdparent->_left;
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				gdparent->_col = RED;
			}
			else
			{
				if (cur == parent->_right)
				{
					RotateLeft(gdparent);
					parent->_col = BLACK;
					gdparent->_col = RED;
				}
				//     g
				//  par  un
				//    cur
				else
				{
					RotateRight(parent);
					RotateLeft(gdparent);
					cur->_col = BLACK;
					//parent->_col = RED;
					gdparent->_col = RED;
				}

				break;
			}
		}

		cur = gdparent;
		parent = cur->_parent;
	}

	//根必须是黑色
	_root->_col = BLACK;
	return std::make_pair(iterator(newnode), true);;
}

set和map的仿函数如下：

struct SetOfK
{
	const K& operator()(const K& key)
	{
		return key;
	}
};

struct SetOfV
{
	const K& operator()(const std::pair<const K, V>& kv)
	{
		return kv.first;
	}
};

全

#pragma once
#include <iostream>
#include <assert.h>
#include <queue>

template <class K, class T, class KeyOfT>
class RBTree
{
	typedef TreeNode<T> node;
public:
	typedef __RBTreeIterator<T, T&, T*> iterator;
	typedef __RBTreeIterator<T, const T&, const T*> const_iterator;

	iterator begin()
	{
		//中序第一个,最左节点
		node* cur = _root;
		while (cur && cur->_left)
		{
			cur = cur->_left;
		}
		return iterator(cur);
	}

	const_iterator begin() const
	{
		//中序第一个,最左节点
		node* cur = _root;
		while (cur && cur->_left)
		{
			cur = cur->_left;
		}
		return const_iterator(cur);
	}

	iterator end()
	{
		return iterator(nullptr);
	}

	const_iterator end() const
	{
		return const_iterator(nullptr);
	}

	node* find(const K& key)
	{
		KeyOfT kot;
		if (_root == nullptr)
		{
			return nullptr;
		}

		node* cur = _root;
		while (cur)
		{
			if (kot(key) < kot(cur->_data))
			{
				cur = cur->_left;
			}
			else if (kot(key) > kot(cur->_data))
			{
				cur = cur->_right;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}

	std::pair<iterator, bool> insert(const T& data)
	{
		KeyOfT kot;
		if (_root == nullptr)
		{
			_root = new node(data);
			_root->_col = BLACK;
			return std::make_pair(iterator(_root), true);
		}

		node* parent = nullptr;
		node* cur = _root;
		while (cur)
		{
			parent = cur;
			if (kot(data) < kot(cur->_data))
			{
				cur = cur->_left;
			}
			else if (kot(data) > kot(cur->_data))
			{
				cur = cur->_right;
			}
			else
			{
				return std::make_pair(iterator(cur), false);;
			}
		}
		//插入
		cur = new node(data);
		node* newnode = cur;
		cur->_parent = parent;
		if (data < parent->_data)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}

		//父节点是红色调整
		while (parent && parent->_col == RED)
		{
			node* gdparent = parent->_parent;
			node* uncle;

			if (gdparent->_left == parent)
			{
				uncle = gdparent->_right;
				//第一种情况 叔叔节点是红色,变色
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					gdparent->_col = RED;
				}
				//第二种情况 分左右
				//     g
				//  par  un
				// cur
				else
				{
					if (cur == parent->_left)
					{
						RotateRight(gdparent);
						parent->_col = BLACK;
						gdparent->_col = RED;
					}
					//     g
					//  par  un
					//    cur
					else
					{
						RotateLeft(parent);
						RotateRight(gdparent);
						cur->_col = BLACK;
						parent->_col = RED;
						gdparent->_col = RED;
					}

					break;
				}
			}
			else
			{
				uncle = gdparent->_left;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					gdparent->_col = RED;
				}
				else
				{
					if (cur == parent->_right)
					{
						RotateLeft(gdparent);
						parent->_col = BLACK;
						gdparent->_col = RED;
					}
					//     g
					//  par  un
					//    cur
					else
					{
						RotateRight(parent);
						RotateLeft(gdparent);
						cur->_col = BLACK;
						//parent->_col = RED;
						gdparent->_col = RED;
					}

					break;
				}
			}

			cur = gdparent;
			parent = cur->_parent;
		}

		//根必须是黑色
		_root->_col = BLACK;
		return std::make_pair(iterator(newnode), true);;
	}

	void RotateLeft(node* parent)
	{
		node* sub = parent->_right;
		node* subl = sub->_left;

		sub->_left = parent;
		parent->_right = subl;

		//父节点修改
		node* Pparent = parent->_parent;
		parent->_parent = sub;
		//有子节点改变指向
		if (subl)
		{
			subl->_parent = parent;
		}

		if (parent == _root)
		{
			_root = sub;
		}
		else
		{
			//原parent在父节点的左右
			if (Pparent->_left == parent)
			{
				Pparent->_left = sub;
			}
			else
			{
				Pparent->_right = sub;
			}
		}

		sub->_parent = Pparent;

	}

	void RotateRight(node* parent)
	{
		node* sub = parent->_left;
		node* subr = sub->_right;

		sub->_right = parent;
		parent->_left = subr;

		if (subr)
		{
			subr->_parent = parent;
		}

		node* Pparent = parent->_parent;
		parent->_parent = sub;

		if (parent == _root)
		{
			_root = sub;
		}
		else
		{
			if (Pparent->_left == parent)
			{
				Pparent->_left = sub;
			}
			else
			{
				Pparent->_right = sub;
			}
		}

		sub->_parent = Pparent;
	}

	bool IsBalance()
	{
		if (_root->_col == RED)
		{
			std::cout << "根节点是红色" << std::endl;
			return false;
		}

		int refVal = 0;  //记录最左路径黑色节点的数量,用来参考
		node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				refVal++;
			}

			cur = cur->_left;
		}

		return _IsBalance(_root, 0, refVal);
	}

	bool _IsBalance(node* cur, int blackNum, int refVal)
	{
		if (cur == nullptr)
		{
			//判断每条路径黑色节点数量正常
			if (blackNum != refVal)
			{
				std::cout << "黑色节点数量不相等" << std::endl;
				return false;
			}
			return true;
		}

		if (cur->_col == BLACK)
		{
			blackNum++;
		}

		if (cur->_col == RED && cur->_parent->_col == RED)
		{
			std::cout << cur->_kv.first << " 连续红色节点" << std::endl;
		}

		return _IsBalance(cur->_left, blackNum, refVal)
			&& _IsBalance(cur->_right, blackNum, refVal);
	}

	void layer()
	{
		if (_root == nullptr)
		{
			return;
		}

		std::queue<node*> q;
		q.push(_root);
		int lay = 1;

		while (!q.empty())
		{
			std::cout << "第" << lay << "层: ";
			int num = q.size();
			while (num--)
			{
				node* cur = q.front();
				q.pop();
				std::cout << cur->_kv.first << " 颜色:" << cur->_col << "  ";
				if (cur->_left != nullptr)
				{
					q.push(cur->_left);
				}
				if (cur->_right != nullptr)
				{
					q.push(cur->_right);
				}
			}

			lay++;
			std::cout << std::endl;
		}
		std::cout << std::endl;
	}

	void inorder()
	{
		_inorder(_root);
		std::cout << std::endl;
	}
	void _inorder(node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_inorder(root->_left);
		std::cout << root->_kv.first << " ";
		_inorder(root->_right);
	}

	int size()
	{
		return _size(_root);
	}

	int _size(node* node)
	{
		if (node == nullptr)
		{
			return 0;
		}

		return _size(node->_left) + _size(node->_right) + 1;
	}

	int TreeHeight()
	{
		return _TreeHeight(_root);
	}

	int _TreeHeight(node* node)
	{
		if (node == nullptr)
		{
			return 0;
		}

		int lhight = _TreeHeight(node->_left);
		int rhight = _TreeHeight(node->_right);

		return lhight > rhight ? lhight + 1 : rhight + 1;
	}

private:
	node* _root = nullptr;
};

set

在这里插入图片描述
两个参数都用K初始化，传入仿函数
在这里插入图片描述
普通迭代器也用const，保证key不被修改，typename用来区分是一个类还是变量类型

全

#pragma once
#include "RBTree.h"

template <class K>
class set
{
	struct SetOfK
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};

public:
	//typename 区分是类还是变量
	typedef typename RBTree<K, K, SetOfK>::const_iterator iterator;
	typedef typename RBTree<K, K, SetOfK>::const_iterator const_iterator;


	iterator begin()
	{
		return _t.begin();
	}

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

	std::pair<iterator, bool> insert(const K& key)
	{
		return _t.insert(key);
	}

private:
	RBTree<K, K, SetOfK> _t;
};

map

在这里插入图片描述
map第一个是K，用来erase，find等函数接口是key，它的数据类型是pair

V& operator[](const K& key)
{
	std::pair<iterator, bool> ret = _t.insert(make_pair(key, V()));
	return ret.first->second;
}

map提供[]操作，返回key位置的值，并可以对自身修改

全

#pragma once
#include <iostream>
#include "RBTree.h"

template <class K, class V>
class map
{
	struct SetOfV
	{
		const K& operator()(const std::pair<const K, V>& kv)
		{
			return kv.first;
		}
	};

public:

	typedef typename RBTree<K, std::pair<const K, V>, SetOfV>::iterator iterator;
	iterator begin()
	{
		return _t.begin();
	}

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

	std::pair<iterator, bool> insert(const std::pair<const K, V> kv)
	{
		return _t.insert(kv);
	}

	V& operator[](const K& key)
	{
		std::pair<iterator, bool> ret = _t.insert(make_pair(key, V()));
		return ret.first->second;
	}

private:
	RBTree<K, std::pair<const K, V>, SetOfV> _t;
};

整体结构

在这里插入图片描述

且听吟风°
关注
专栏目录
STL库：map和set
修行的凡人的博客
11-14 3653
基于著名书籍和自我学习得出的map和set精华知识
map和set的模拟实现
06-06
本文将深入探讨如何通过封装红黑树来模拟实现Map和Set。 红黑树是一种自平衡二叉查找树，它的主要特性是每个节点都带有颜色属性（红色或黑色），并且遵循以下性质： 1. 每个节点要么是黑色，要么是红色。 2. 根节点...
map和set的封装
2301_78731445的博客
09-02 1096
map和set的底层都是用一棵红黑树来封装的，但是map和set节点里面存储的值不一样，map存储的是<key,pair<key,value>>，set存储的<key,key>，多存储一个key是因为查找节点的需要（查找节点一般是按照key去查找的），所以统一用data来表示map和set存储的数据，再在map和set内部定义一个仿函数，通过传参使用函数对象来获得data中具体的key值{}//set的keyoftreturn key;//map的keyofT二、红黑树的迭代器。
c++——map和set的封装
Britney_dark的博客
11-20 853
如果结果不如你所愿，就在尘埃落定前奋力一搏！
c++ map，set封装
2301_78323041的博客
05-12 895
map 是一个 kv 结构， set 是 k结构。我们前面模拟实现了 红黑树，但是我们实现的红黑树把 kv 结构写死了，怎么样才能用泛型编程的思想来实现map和set呢我们先简单看一下原码中是怎么实现的。
C++之map和set 的封装
qq_74732628的博客
05-13 932
文章详细讲解了map和set 的封装过程和底层原理
C++进阶之map与set
cls的博客
05-23 2700
stl中将数据结构叫做容器。 容器分为 序列式容器：vector/list... 就类似线性表 关联史容器：map/set.. 数据之间有强烈的关联性，底层是搜索树 栈和队列是适配器 set底层就是搜索树。 void test_set1() { //排序＋去重 set<int> s; s.insert(3); s.insert(1); s.insert(8); s.insert(2); s.insert(5); s.insert(5); s.insert(5)
C++：map和set的封装原理
海绵宝宝de派小星的博客
11-14 2466
map和set的模拟实现
map和set的异同
爱橙子的OK绷的专栏
03-12 7809
异同分析MAP的节点是一对数据. SET的节点是一个数据.map使用关键值Key来唯一标识每一个成员, map的value值可以重复。 set存储已排序的无重复的元素。都属于关联容器 ，形式不同：map的形式 map<type1, type2> mymap; set的形式 set<type> myset; set（集合）——包含了经过排序了的数据，这些数据的值(v
C++语法——map与set的封装原理
weixin_61857742的博客
12-01 1081
list迭代器是用类封装，迭代器内部定义一个指针指向节点，对迭代器的操作底层是对迭代器内部指针的操作。迭代器的begin和end只能在rb_tree中实现，对于begin而言，返回红黑树最左节点的迭代器，end返回root的父节点迭代器（空节点迭代器）。其原理就是如果是父节点的左子节点，那么说明父节点在自己之后，如果是右子节点那么说明在父节点之后。对比3号和5号节点，都是叶子节点，但是3号节点++后是1号节点，5号++后是6号节点。对比节点3和节点5，节点3--之后是节点2，节点5--之后是节点4。
【C++】set和map
m0_62179366的博客
11-06 7420
map与set也十分的相似，map是K/V的模型，set是K的模型map也有两种区别与set和multiset相同，只是键值是否允许冗余的差别不过map的插入就比较特别了我们发现insert的参数是一个value_type类型然后我们发现它实际上是一个pair{T1 first;T2 second;{}{}};用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值，value表示与key对应的信息。
哈希map以及set的封装
04-05
在这个场景中，我们讨论的是C++中的哈希表实现，即`哈希map`和`哈希set`的封装，它们是STL（标准模板库）的一部分，由`unordered_map`和`unordered_set`两个容器来表示。 首先，我们来看`哈希map`。`std::unordered...
红黑树封装实现map和set
06-20
封装红黑树实现map和set解决方案
c++容器list、vector、map、set区别与用法详解
12-17
c++容器list、vector、map、set区别 list 封装链表，以链表形式实现，不支持[]运算符。 对随机访问的速度很慢(需要遍历整个链表)，插入数据很快(不需要拷贝和移动数据，只需改变指针的指向)。 新添加的元素，...
C++ STL中sort函数
最新发布
weixin_43349440的博客
09-15 145
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
C++与QML的数据交互
qq_50679120的博客
09-11 486
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
C和指针：标准函数库
暮色年华的博客
09-11 670
longjmp 函数:一旦在程序的其他部分遇到了 longjmp 调用，并且传入了之前 setjmp 初始化的 jmp_buf 数组以及一个非零值作为跳转值，那么程序的控制就会立即跳回到与那个 jmp_buf 关联的 setjmp 处。setjmp 函数：一个函数中调用 setjmp 并传递一个类型为 jmp_buf 的数组作为参数时，setjmp 将会保存当前程序执行环境的一个快照（包括处理器寄存器和程序计数器等状态信息）到这个 jmp_buf 数组中。如果在某个低层的函数中检测到一个错误，你可以立。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 453
继续学习头文件的数学函数。
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 892
set、map仿STL模拟实现
SolrTemplate query 返回结果封装为map集合
03-25
在上面的代码中，我们先定义了一个List<Map, Object>>类型的结果集，然后创建了一个Query对象，设置了查询条件、返回结果数量、排序方式和返回字段等参数。通过调用solrTemplate.query方法执行查询操作，得到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值