学习-＞C++篇十六：哈希表与unordered_map、unordered_set

已于 2022-11-17 13:21:31 修改
阅读量568 收藏
点赞数 3
分类专栏： 数据结构 C++ 文章标签： 散列表 数据结构
于 2022-11-17 13:20:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014801954/article/details/127480201
版权

目录

 

1.哈希表概念          

2.常用哈希函数：

解决哈希冲突的两个方法：

一.闭散列法（开放定址法）：

二.开散列法（哈希桶）：

3.封装unordered_map,unordered_set

 1.哈希表概念          

顺序结构以及平衡树中，元素键值与其存储位置之间没有对应的关系，因此在查找一个元素
时，必须要经过键值的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即
O(log2N)，搜索的效率取决于搜索过程中元素的比较次数，倘若无需进行多次比较，直接从表中获得所需的元素，这就需将键值和存储位置建立映射关系，以便快速查找元素。
        该方法为 哈希法（散列法），哈希方法中使用将键值转换为存储位置的转换函数称为哈希(散列)函数，构造出来的结构称 为 哈希表(或散列表）。
        哈希冲突：不同关键字通过相同哈希函数计算出相同的哈希地址，该种现象称为哈希冲突 或哈希碰撞。

2.常用哈希函数：

        1. 直接定址法--(常用) 取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B
优点：简单、均匀
缺点：需要事先知道关键字的分布情况
使用场景：适合查找比较小且连续的情况
        2. 除留余数法--(常用) 设散列表中的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数， 按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址。

解决哈希冲突的两个方法：

一.闭散列法（开放定址法）：

1.线性探测法：
代码模拟实现： 
#pragma once
#include<unordered_map>
#include<vector>
using std::vector;
using std::pair;

//线性探测法
// 
//给每一个空间标记
enum state{EXIST,DELETE,EMPTY};
template<class K,class V>
class hashtable
{
	//表中存储elem结构，包含pair键值对和标记状态的state
	struct elem
	{
		pair<K, V> _val;
		state _state;
	};

public:
	hashtable(size_t capacity=3)
		:_ht(capacity)
		,_size(0)
	{
		for (size_t i = 0; i < capacity; i++)
		{
			_ht[i]._state = EMPTY;
		}
	}
	~hashtable()
	{}

	bool Insert(const pair<K, V>& val)
	{
		checkCapacity();
		size_t hashi = val.first % _ht.size();
		while (_ht[hashi]._state != EMPTY)
		{
			if (_ht[hashi]._state == EXIST 
				&& _ht[hashi]._val.first == val.first)
				return false;
			++hashi;
			if (hashi == _ht.size())
				hashi = 0;
		}
		_ht[hashi]._state = EXIST;
		_ht[hashi]._val = val;
		_size++;
		return true;
	}

	elem* Find(const K& k)
	{
		if (_ht.size() == 0)
			return nullptr;
		size_t hashi = k % _ht.size();
		while (_ht[hashi]._state != EMPTY)
		{
			if (_ht[hashi]._state == EXIST && _ht[hashi]._val.first == k)
				return &_ht[hashi];
			++hashi;
			if (hashi == _ht.size())
				hashi = 0;
		}
		return nullptr;
	}
private:
	void checkCapacity()
	{
		if (_size * 10 / _ht.size() >= 7)
		{
			size_t newsize = _ht.size() * 2;
			hashtable<K,V>newht(newsize);
			for (auto e : _ht)
			{
				if (e._state == EXIST)
					newht.Insert({ e._val.first,e._val.second });
			}
			newht._size = _size;
			newht._ht.swap(_ht);
		}
	}

	bool Erase(const K&k)
	{
		if (elem* p = Find(k))
		{
			p->_state = DELETE;
			--_size;
			return true;
		}
		return false;
	}
	size_t HashFunc(const K& k)
	{
		return k % _ht.size();
	}
private:
	vector<elem>_ht;
	size_t _size;
};
2.二次探测法：
与线性探测法类似，将插入和查找的探测元素的顺序变成hashi，hashi+1^2，hashi+2^2,hashi+3^2......即可，记得计算好的哈希地址对哈希表的总大小取模，代码如下： 
//二次探测法
	bool Insert(const pair<K, V>& val)
	{
		checkCapacity();
		size_t hashi = val.first % _ht.size();
		size_t index = hashi;
		int i = 0;
		while (_ht[hashi]._state != EMPTY)
		{
			if (_ht[hashi]._state == EXIST
				&& _ht[hashi]._val.first == val.first)
				return false;
			++i;
			hashi=index+i*i;
			hashi %= _ht.size();
		}
		_ht[hashi]._state = EXIST;
		_ht[hashi]._val = val;
		_size++;
		return true;
	}


	//二次探测法
	elem* Find(const K& k)
	{
		if (_ht.size() == 0)
			return nullptr;
		size_t hashi = k % _ht.size();
		size_t index = hashi;
		int i = 0;
		while (_ht[hashi]._state != EMPTY)
		{
			if (_ht[hashi]._state == EXIST && _ht[hashi]._val.first == k)
				return &_ht[hashi];
			i++;
			hashi=index+i*i;
			hashi %= _ht.size();
		}
		return nullptr;
	}

二.开散列法（哈希桶）：

开散列法：首先对关键码的集合通过哈希函数映射到对应地址，具有相同地址的的关键码归于同一个子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。（即将哈希冲突的元素放在单链表中）

简单实现：

namespace openhash
{
	template<class V>
	struct hashBucketNode
	{
		hashBucketNode(const V& data)
			:_next(nullptr)
			, _data(data)
		{}

		hashBucketNode<V>* _next;
		V _data;
	};

	template<class V>
	class hashBucket
	{
		typedef hashBucketNode<V> Node;
	public:
		hashBucket(size_t capacity = 3)
			:_size(0)
		{
			_ht.resize(capacity, nullptr);
		}

		Node* insert(const V& data)
		{
			//几号桶
			size_t Bucketi = data % _ht.size();
			Node* cur = _ht[Bucketi];
			while (cur)
			{
				if (cur->_data == data)
					return cur;
				cur = cur->_next;
			}
			Node* newnode = new Node(data);
			newnode->_next = _ht[Bucketi];
			_ht[Bucketi] = newnode;
			_size++;
			return newnode;
		}

		Node* erase(const V& data)
		{
			size_t Bucketi = data % _ht.size();
			Node* cur = _ht[Bucketi], prev = nullptr;
			while (cur)
			{
				if (cur->_data == data)
				{
					if (prev)
						prev->_next = cur->_next;
					else
						_ht[Bucketi] = cur->_next;
					//返回删除元素的下一个节点
					prev = cur->_next;
					delete cur;
					--_size;
					return prev;
				}
			}
			return nullptr;
		}

		Node* Find(const V& data)
		{
			size_t Bucketi = data % _ht.size();
			Node* cur = _ht[Bucketi];
			while (cur)
			{
				if (cur->_data == data)
					return cur;
				cur = cur->_next;
			}
			return nullptr;
		}
		size_t size()const { return _size; }
		bool Empty()const { return _size == 0; }
		void clear()
		{
			for (int i = 0; i < _ht.size(); i++)
			{
				while (_ht[i])
				{
					Node* cur = _ht[i];
					_ht[i] = cur->_next;
					delete cur;
				}
			}
			_size = 0;
		}
		~hashBucket() { clear(); }
	private:
		size_t hashFunc(const V& data) { return data % _ht.size(); }
	private:
		vector<Node*> _ht;
		size_t _size;
	};
}

开散列法的扩容：

因为扩容时桶的总数改变了，每个元素需要重新映射地址，所以有大的性能消耗。理想情况下是每个桶一个元素，于是，可以在桶的个数等于存储的元素个数的时候进行哈希表的扩容操作。

扩容代码：（将原链表节点一个个插入到新的哈希桶）

size_t BucketCount()const
		{
			size_t bc = 0;
			for (auto p : _ht)
				if (p)++bc;
			return bc;
		}
	private:
		void checkCapacity()
		{
			if (BucketCount() == _size)
			{
				vector<Node*>newht(_size == 0 ? 3:_size * 2);
				for (auto& p : _ht)
				{
					Node* pnode = p;
					while (pnode)
					{
						p = p->_next;
						size_t Bucketi = pnode->_data % newht.size();
						pnode->_next = newht[Bucketi];
						newht[Bucketi] = pnode;
						pnode = p;
					}
				}
				_ht.swap(newht);
			}
		}

3.封装unordered_map,unordered_set

上述实现是将key取模得到存储地址，如果要处理字符串，则需提供字符串哈希函数，如果要处理自定义类型也需提供哈希函数，可以通过传入仿函数实现，为封装unordered_map和unordered_set还需实现迭代器，与红黑树类似，还需有一个取value中key的仿函数。
简单实现封装如下： 
//hashtable11-3.h

namespace openhash
{
	template<class T>
	struct HashFunc
	{
		//默认的哈希函数
		size_t operator()(const T& val) { return val; }
	};
	//针对字符串哈希函数->模板特化
	template<>
	struct HashFunc<string>
	{
		size_t operator()(const string& s)
		{
			const char* str = s.c_str();
			size_t seed = 31;
			size_t hash = 0;
			while (*str)
			{
				hash = hash * seed + (*str++);
			}
			return hash;
		}
	};

	//定义节点：存储的T可能是K,也可能是pair<K,V>
	template<class T>
	struct HashNode
	{
		HashNode(const T&data)
			:_next(nullptr)
			,_data(data)
		{}
		HashNode<T>* _next;
		T _data;
	};

	//迭代器需用到哈希桶，要做前置声明
	template<class K,class T,class KeyOfT,class HashFunc>
	class HashBucket;

	//实现迭代器，其中有一个节点指针和哈希桶的指针
	template<class K,class T,class KeyOfT,class HashFunc>
	class __HBIterator
	{
		typedef HashNode<T> Node;
		typedef HashBucket<K, T, KeyOfT, HashFunc>* Phb;
		typedef __HBIterator<K, T, KeyOfT, HashFunc> Self;
	public:
		__HBIterator(){}
		__HBIterator(Node*node,Phb phb)
			:_node(node),_phb(phb)
		{}

		//单向迭代器只需实现++
		Self& operator++()//前置加加
		{
			assert(_node);//当_node为空(即end，不可以++)
			if (_node->_next)
				_node = _node->_next;
			else
			{
				KeyOfT kot;
				HashFunc hf;
				size_t sz = _phb->_table.size();
				//计算下一个桶
				size_t hashi = hf(kot(_node->_data)) % sz + 1;
				//寻找下一个不为nullptr的桶
				while (hashi < sz && !_phb->_table[hashi])
					++hashi;
				if (hashi == sz)
					_node = nullptr;//已经走完最后一个哈希桶
				else
					_node = _phb->_table[hashi];
			}
			return *this;
		}

		Self& operator++(int)//后置加加
		{
			Self ret(_node, _phb);
			operator++();
			return ret;
		}

		T& operator*() { return _node->_data; }
		T* operator->() { return &_node->_data; }
		bool operator!=(const Self& s) const { return _node != s._node; }
		bool operator==(const Self& s) const { return _node == s._node; }
	private:
		Node* _node;
		Phb _phb;
	};

	template<class K,class T,class KeyOfT,class HashFunc>
	class HashBucket
	{
		template<class K,class T,class KeyOfT,class hashFunc>
		friend class __HBIterator;//将迭代器作为哈希桶的友元类模板，以便能访问哈希表(遍历桶)
		typedef HashNode<T> Node;
	public:
		typedef __HBIterator<K, T, KeyOfT, HashFunc> Iterator;
		Iterator begin()
		{
			for (auto p : _table)
				if (p)return Iterator(p, this);
			return Iterator(nullptr, this);
		}
		Iterator end() { return Iterator(nullptr, this); }

		HashBucket(size_t capacity = 0)
			:_table(GetNextPrime(_table.size()),nullptr)
			,_size(0)
		{}

		~HashBucket() { Clear(); }

		void Clear()
		{
			for (size_t i = 0; i < _table.size(); i++)
			{
				while (_table[i])
				{
					Node* cur = _table[i];
					_table[i] = cur->_next;
					delete cur;
				}
			}
			_size = 0;
		}

		Iterator find(const K& key)
		{
			HashFunc hf;
			size_t hashi = hf(key) % _table.size();
			Node* cur = _table[hashi];
			while (cur)
			{
				if (KeyOfT()(cur->_data) == key)
					return Iterator(cur, this);
				cur = cur->_next;
			}
			return Iterator(nullptr, this);
		}

		pair<Iterator, bool> insert(const T& data)
		{
			Iterator it = find(KeyOfT()(data));
			if (it != end())
				return make_pair(it, false);
			checkCapacity();
			Node* newnode = new Node(data);
			size_t hashi = HashFunc()(KeyOfT()(data)) % _table.size();
			newnode->_next = _table[hashi];
			_table[hashi] = newnode;
			++_size;
			return make_pair(Iterator(newnode, this), true);
		}

		size_t erase(const K& key)
		{
			KeyOfT kot;
			HashFunc hf;
			size_t hashi = hf(key)%_table.size();
			Node* prev = nullptr;
			Node* cur = _table[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					if (prev)
						prev->_next = cur->_next;
					else
						_table[hashi] = cur->_next;
					delete cur;
					--_size;
					return 1;
				}
				prev = cur;
				cur = cur->_next;
			}
			return 0;
		}

	private:
		//将桶的数量设置为一个素数，据说能减少哈希冲突
		size_t GetNextPrime(size_t prime)
		{
			const int PRIMECOUNT = 28;
			//素数表
			static const size_t primeList[PRIMECOUNT] =
			{
				53ul, 97ul, 193ul, 389ul, 769ul,
				1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
				49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
				1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
				50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
				1610612741ul, 3221225473ul, 4294967291ul
			};

			// 获取比prime大那一个素数
			size_t i = 0;
			for (; i < PRIMECOUNT; ++i)
			{
				if (primeList[i] > prime)
					return primeList[i];
			}
			return primeList[i];
		}

		void checkCapacity()
		{
			if (_size == _table.size())
			{
				KeyOfT kot;
				HashFunc hf;
				vector<Node*>newtable(GetNextPrime(_table.size()),nullptr);
				for (auto p : _table)
				{
					auto cur = p;
					while (cur)
					{
						Node* next = cur->_next;
						cur->_next = newtable[hf(kot(p->_data))];
						newtable[hf(kot(p->_data))] = cur;
						cur = next;
					}
				}
				newtable.swap(_table);
			}
		}
	private:
		vector<Node*>_table;
		size_t _size;
	};
}
封装unordered_map和unordered_set类似：
unordered_map主要要多实现一个operator[]函数，注意这个函数是先调用insert实现的。 
#pragma once
#include"hashtable11-3.h"
namespace openhash
{
	template<class K, class V, class HashFunc = HashFunc<K> >
	class unordered_map
	{
		struct MapKeyOfT { const K& operator()(const pair<K, V>& p) { return p.first; } };
	public:
		typedef typename HashBucket<K, pair<K, V>, MapKeyOfT, HashFunc>::Iterator iterator;
		iterator begin() { return _hb.begin(); }
		iterator end() { return _hb.end(); }

		iterator find(const K& key) {
			return _hb.find(key);
		}
		size_t erase(const K& key) {
			return _hb.erase(key);
		}
		pair<iterator, bool>insert(const pair<K, V>& p) {
			return _hb.insert(p);
		}
		V& operator[](const K& k) {
			pair<iterator, bool>p = insert(make_pair(k, V()));
			return p.first->second;
		}
	private:
		HashBucket<K, pair<K, V>, MapKeyOfT, HashFunc>_hb;
	};
}
#pragma once
namespace openhash
{
#include"hashtable11-3.h"
	template<class K, class HashFunc = HashFunc<K> >
	class unordered_set
	{
		struct SetKeyOfT { const K& operator()(const K& k) { return k; } };
	public:
		typedef typename HashBucket<K,K,SetKeyOfT, HashFunc>::Iterator iterator;
		iterator begin() { return _hb.begin(); }
		iterator end() { return _hb.end(); }

		iterator find(const K& key) {
			return _hb.find(key);
		}
		size_t erase(const K& key) {
			return _hb.erase(key);
		}
		pair<iterator, bool>insert(const K& k) {
			return _hb.insert(k);
		}
	private:
		HashBucket<K, K, SetKeyOfT, HashFunc>_hb;
	};
}

且随疾风前行->
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈希表和unordered_map的初步了解
qq_72577060的博客
05-05 174
哈希表是根据关键码值(Key value)而直接进行访问的数据结构。哈希表将关键码值映射到表中一个位置来访问记录。哈希表加快了访问速度。哈希表有对应的哈希函数本质上是一个散列函数，k指代关键字值key。
C++【unordered_map/set的底层实现-哈希表】—含有源代码
m0_59292239的博客
06-09 2873
C++【unordered_map/set的底层实现-哈希表】—含有源代码
【C++】哈希、unordered_map/unordered_set
qq_63989073的博客
12-09 707
在c++11中，STL新提供了4个unordered系列的关联式容器，用于应对红黑树节点太多导致的查询效率不理想的问题，新增的容器使用方法与红黑树结构的关联式容器基本相同，只是底层结构不同。
C++哈希表模拟实现unordered_map 与unordered_set
最新发布
weixin_73142957的博客
01-26 946
C++哈希表模拟实现unordered_map 与unordered_set
【C++从0到1】第十九篇：哈希（上）
Pass-by
05-30 631
文章目录一、unordered系列关联式容器1.1 unordered_map1.1.1 unordered_map的文档介绍1.1.2 unordered_map的接口说明 一、unordered系列关联式容器 在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 ，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器
robin-hood-hashing：基于C ++ 11141720的基于robin hood哈希的快速且内存高效的哈希表
01-30
robin_hood::unordered_map和robin_hood::unordered_set是std::unordered_map / std::unordered_set独立于平台的替代品，对于实际的用例而言，它既更快，更高效。 安装及使用 直接纳入 将添加到您的C ++项目。 ...
算法（42）-数组等值切割-前缀累加和-哈希表Map-set版-C++
01-07
题目：给定正整数，返回该数组能不能分成4... set和map两种哈希表类型。其实没啥本质差别。 1.unordered_set版   bool canSplits_set(vci arr) { if (arr.size() < 7) { return false; } unordered_set m
ordered-map：保留插入顺序的C ++哈希映射和哈希集
02-02
在C++标准库中，`std::unordered_map`是一个基于哈希表的数据结构，提供了O(1)的平均查找时间复杂度。然而，它并不保证元素的插入顺序。`ordered-map`库解决了这个问题，它创建了一个哈希表，其中的迭代器会按照元素...
哈希表应用C++_STL_hash
12-14
- **创建与初始化**：可以使用`std::unordered_set<类型>`或`std::unordered_map<键类型, 值类型>`创建哈希表。初始化时，可以使用大括号{}或者`insert()`函数添加元素。 - **操作函数**：`insert()`用于插入元素...
C++源代码：哈希表算法
06-28
以上就是一个基础的C++哈希表实现，可以根据具体需求扩展哈希函数和冲突解决策略。理解哈希表的工作原理和C++中的实现方式，对于提升程序性能和优化数据结构设计都具有重要意义。在实际编程中，可以灵活运用`std::...
数据结构（9）-- 哈希表 unordered_map
看，未来的博客
02-14 2899
文章目录哈希散列表小故事加载因子哈希函数的安全我的困惑资料 哈希散列表 需要我说一下什么是哈希表吗？上面那张图可以先看一下，然后我搬一段官方话过来。 哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 哈希表hashtable(key，value) 就是把Key通过一个固定的算法函数既所谓的哈希函数转换成一个整型数字，然后就.
map 学习（下）——C++ 中的 hash_map, unordered_map
热门推荐
琦小虾的代码世界
11-16 1万+
map 学习（下）——C++ 中的 hash_map, unordered_map 总结 C++ 中关于 hash_map 与 unordered_map 的相关内容与优劣势比较。
unordered_map之自定义哈希函数
m0_51262775的博客
10-24 1138
struct custom_hash { static uint64_t splitmix64(uint64_t x) { x += 0x9e3779b97f4a7c15; x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; x = (x ^ (x >> 27)) * 0x94d049bb133111eb; return x ^ (x >> 31); }
C++ map/unordered_map怎么设置自定义哈希函数（Hash）和相等函数（equal_to）以及如何delete键值中指针的内存
xiduohan4432的博客
08-02 2325
C++ map/unordered_map怎么设置自定义哈希函数（Hash）和相等函数（equal_to）以及如何delete键值中指针的内存
unordered_map/unorderd_set使用与哈希介绍
Adenson的博客
07-01 660
在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 O(logN)，即最差情况下 需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次 数就能够将元素找到，因此在C++11中，STL又提供了4个unordered系列的关联式容器。 unordered_map/unordered_set/unordered_multimap/unordered_multiset 这四个容器与关联式容器（map、set、multimap、multiset
C++哈希表unordered_map，推荐使用。
学无止境
03-17 7451
在一个字符串(1 解法1：使用数组，int hash[256]; 这题我竟然在想其他的歪点子，没想到第二次直接从数组0位置开始遍历（好蠢）（而不是哈希容器），不要动不动就想遍历哈希容器。 class Solution { public: int FirstNotRepeatingChar(string str) { if(str.empty()) return -1;
unordered_map 的哈希函数
H_ang的博客
03-09 3321
题目链接：http://codeforces.com/contest/1133/problem/D 上篇博客的题：https://mp.csdn.net/mdeditor/88364092# 用了map&amp;amp;amp;lt;pair&amp;amp;amp;lt;int, int&amp;amp;amp;gt;, int &amp;amp;amp;gt; p; 现在我想知道用unordered_map是否会快一些。 把map换成unordered_map编译报错。
unordered_map和unordered_set的实现——哈希表实现及封装
代码笔记本
01-29 870
文章目录1.两者与map及set的关系2.std::find和unordered_set::find3.随机数据测试4.底层结构4.1哈希概念4.2哈希冲突4.3哈希函数4.3.1直接定址法(常用)4.3.2除留余数法(常用)5.解决哈希冲突5.1闭散列——开放定址法5.1.1线性探测5.1.2二次探测5.1.3负载因子5.1.4模拟实现5.1.4.1判空5.1.4.2取模的选择5.1.4.3扩容的要求5.1.4.4仿函数处理各种类型转成整数5.1.5小结5.2开散列——哈希桶/拉链法5.2.1概念5.2.
C++哈希表中unordered_set和unordered_map的区别
09-01
1. 底层实现：unordered_set和unordered_map的底层都是哈希表，而set和map的底层是红黑树。哈希表是一种根据键值直接进行访问的数据结构，而红黑树是一种自平衡的二叉搜索树。 2. 排序：unordered_set是不可排序的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值