[C++]哈希

最新推荐文章于 2024-09-14 22:25:23 发布
最新推荐文章于 2024-09-14 22:25:23 发布
阅读量1k 收藏 10
点赞数 12
分类专栏： 数据结构 C++ 文章标签： 哈希算法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71071692/article/details/140396685
版权

一、概念

在顺序结构以及平衡树中，元素关键码（key）与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码（key）的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(log2 N)，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(HashFunc)使元素的存储位置与它的关键码（key）之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

哈希函数：

哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)

哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。

哈希冲突：

对于两个数据元素的关键字 和 (i != j)，有 != ，但有：Hash( ) == Hash( )，即：不同关键字通过
相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。
把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。
发生哈希冲突该如何处理呢？

常见处理：

引起哈希冲突的一个原因可能是：哈希函数设计不够合理。 哈希函数设计原则：

  • 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
  • 哈希函数计算出来的地址能均匀分布在整个空间中
  • 哈希函数应该比较简单

1. 直接定址法

取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B 优点：简单、均匀 缺点：需要事先知道关键字的分布情况 使用场景：适合查找比较小且连续的情况 。

2. 除留余数法

设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址。


此外，还有平方取中法、折叠法、数学分析法等
注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突

解决哈希冲突两种常见的方法是：闭散列和开散列

二、闭散列（开放定址法）

1、概念

当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。

线性探测：

从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

优点：实现非常简单，
缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同关键码占据
了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低。如何缓解呢？

二次探测：

线性探测的缺陷是产生冲突的数据堆积在一块儿，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为： = (H0 + i^2)% m,或者： = (H0 - i^2)% m。其中：i = 1,2,3…，H0是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小。

2、模拟实现：

namespace Close_Hash //闭散列
{
	enum State 
	{ 
		EMPTY, 
		EXIST, 
		DELETE 
	};

	template<class K, class V>
	class HashTable
	{
		struct Node
		{
			pair<K, V> _val;
			State _state;
		};

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

		// 插入
		bool Insert(const pair<K, V>& val)
		{
			if (_totalSize == 0)
			{
				_totalSize = 3;
			}
			else if (Find(val.first))
			{
				return false;
			}
			else if (_size * 10 / _totalSize >= 7)
			{
				size_t totalsize = _totalSize * 2;
				HashTable newht;
				newht._ht.resize(totalsize);
				newht._totalSize = totalsize;
				for (size_t i = 0; i < _totalSize; i++)
				{
					if (_ht[i]._state == EXIST)
					{
						newht.Insert(_ht[i]._val);
					}
				}
				Swap(newht);
			}

			size_t hashi = val.first % _totalSize;
			while (_ht[hashi]._state == EXIST)
			{
				hashi++;
				hashi %= _totalSize;
			}

			
			_ht[hashi]._val = val;
			_ht[hashi]._state = EXIST;

			_size++;

		}

		// 查找
		size_t Find(const K& key)
		{
			size_t hashi = key % _totalSize;
			for (int i = 0; i < _totalSize; i++)
			{
				if (_ht[hashi]._state == EXIST && _ht[hashi]._val.first == key)
				{
					return true;
				}

				hashi++;
				hashi %= _totalSize;
			}

			return false;
		}

		// 删除
		bool Erase(const K& key)
		{
			size_t hashi = key % _totalSize;
			for (int i = 0; i < _totalSize; i++)
			{
				if (_ht[hashi]._state == EXIST && _ht[hashi]._val.first == key)
				{
					_ht[hashi]._state = DELETE;
					_size--;
					return true;
				}

				hashi++;
				hashi %= _totalSize;

			}

			return false;
		}

		size_t Size()const
		{
			return _size;
		}

		bool Empty() const
		{
			return _size == 0;
		}

		void Swap(HashTable<K, V>& ht)
		{
			swap(_size, ht._size);
			swap(_totalSize, ht._totalSize);
			_ht.swap(ht._ht);
		}

		void Print()
		{
			for (int i = 0; i < _totalSize; i++)
			{
				if (_ht[i]._state == EXIST)
				{
					cout << "[" << i << "]->" << _ht[i]._val.first << endl;
				}
				else if (_ht[i]._state == EMPTY)
				{
					cout << "[" << i << "]->EMPTY" << endl;
				}
				else if (_ht[i]._state == DELETE)
				{
					cout << "[" << i << "]->DELTET" << endl;
				}
			}
		}

	private:
		size_t HashFunc(const K& key)
		{
			return key % _ht.capacity();
		}

		void CheckCapacity();
	private:
		vector<Node> _ht;
		size_t _size;
		size_t _totalSize;  
	};
}

三、开散列

1、概念（哈希桶）

首先对关键码（key）集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。

2、模拟实现

template<class T>
struct DefHashF
{
	size_t operator()(T& data)
	{
		return (size_t)data;
	}
};

template<>
struct DefHashF<string>
{
	size_t operator()(const string& key)
	{
		// BKDR
		size_t hash = 0;
		for (auto e : key)
		{
			hash *= 31;
			hash += e;
		}

		cout << key << ":" << hash << endl;
		return hash;
	}
};

template<class T>
struct HashBucketNode
{
	HashBucketNode(const T& data = T())
		:_data(data)
		,_pNext(nullptr)
	{}

	T _data;
	HashBucketNode<T>* _pNext;
};


	template<class K, class V, class KeyOfValue, class HF>
	class HashBucket;


	template <class K, class V, class KeyOfValue, class HF = DefHashF<K>>
	struct Iterator
	{
		typedef HashBucketNode<V>* PNode;
		typedef Iterator<K, V, KeyOfValue, HF> Self;

		Iterator(PNode pNode = nullptr, HashBucket<K, V, KeyOfValue, HF>* pHt = nullptr)
		{
			_pNode = pNode;
			_pHt = pHt;
		}

		Self& operator++()
		{
			// 当前迭代器所指节点后还有节点时直接取其下一个节点
			if (_pNode->_pNext)
				_pNode = _pNode->_pNext;
			else
			{
				// 找下一个不空的桶，返回该桶中第一个节点
				size_t bucketNo = _pHt->HF(KeyOfValue()(_pNode->_data)) + 1;
				for (; bucketNo < _pHt->BucketCount(); ++bucketNo)
				{
					if (_pNode = _pHt->_ht[bucketNo])
						break;
				}
			}

			return *this;
		}

		Self operator++(int)
		{
			Self cur = *this;
			if (_pNode->_pNext)
				_pNode = _pNode->_pNext;
			else
			{
				// 找下一个不空的桶，返回该桶中第一个节点
				size_t bucketNo = _pHt->HashFunc(KeyOfValue()(_pNode->_data)) + 1;
				for (; bucketNo < _pHt->BucketCount(); ++bucketNo)
				{
					if (_pNode = _pHt->_ht[bucketNo])
						break;
				}
			}

			return cur;
		}

		V& operator*()
		{
			return _pNode->_data;
		}

		V* operator->()
		{
			return &(_pNode->_data);
		}

		bool operator==(const Self& it) const
		{
			return _pNode == it._pNode;
		}

		bool operator!=(const Self& it) const
		{
			return _pNode != it._pNode;
		}


		PNode _pNode;             // 当前迭代器关联的节点
		const HashBucket<K, V, KeyOfValue, HF>* _pHt;         // 哈希桶--主要是为了找下一个空桶时候方便
	};

	
	template<class K, class V, class KeyOfValue, class HF>
	class HashBucket
	{
		template <class K, class V, class KeyOfValue, class HF>
		friend struct Iterator;
		KeyOfValue kov;
		HF hf;
		typedef Iterator<K, V, KeyOfValue, HF> iterator;
		typedef HashBucketNode<V> Node;
	public:
		HashBucket()
		{
			_tables.resize(10);
		}

		iterator begin()
		{
			if (_n == 0)
			{
				return iterator(nullptr, this);
			}

			//哈希表中有数据
			for (int i = 0; i < _tables.size(); i++)
			{
				if (_tables[i])
				{
					return iterator(_tables[i], this);
				}
			}
		}

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

		size_t size()const
		{
			return _n;
		}

		bool empty()const
		{
			return _n == 0;
		}


		pair<iterator, bool> InsertUnique(const V& data)
		{
			K key = kov(data);
			iterator it = Find(key);
			if (it._pNode != nullptr)
			{
				return make_pair(it, false);
			}

			if (_n == _tables.size())
			{
				//扩容
				vector<Node*> newt;
				newt.resize(_tables.size() * 2, nullptr);

				for (int i = 0; i < _tables.size(); i++)
				{
					if (_tables[i])
					{
						//桶里有数据
						Node* cur = _tables[i];
						Node* next = nullptr;
						while (cur)
						{
							//放到新桶中
							size_t hashi = kov(cur->_data) % newt.size();
							if (newt[hashi] == nullptr)
							{
								next = cur->_pNext;	//记录下一个数据
								cur->_pNext = nullptr;
								newt[hashi] = cur;

								cur = next;
							}
							else
							{
								Node* ntcur = newt[hashi];
								while (ntcur->_pNext)
								{
									ntcur = ntcur->_pNext;
								}
								next = cur->_pNext;
								ntcur->_pNext = cur;
								cur->_pNext = nullptr;

								cur = next;

							}


						}

						_tables[i] = nullptr;
					}
				}
				swap(newt, _tables);

			}

			Node* newnode = new Node;
			newnode->_data = data;
			newnode->_pNext = nullptr;

			size_t hashi = kov(data) % _tables.size();
			if (_tables[hashi] == nullptr)
			{
				_tables[hashi] = newnode;
			}
			else
			{
				Node* cur = _tables[hashi];

				while (cur->_pNext)
				{
					cur = cur->_pNext;
				}

				cur->_pNext = newnode;
				_n++;

			}
			return make_pair(iterator(newnode, this), true);


		}

		iterator Find(const K& key)
		{
			size_t hashi = key % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kov(cur->_data) == key)
				{
					return iterator(cur, this);
				}

				cur = cur->_pNext;
			}

			return iterator(nullptr, this);
		}

		size_t Count(const K& key)
		{

		}

		pair<iterator, bool> Insert(const V value)
		{
			K key = kov(value);
			iterator it = Find(key);
			if (it._pNode != nullptr)
			{
				return make_pair(it, false);
			}

			if (_n == _tables.size())
			{
				//扩容
				vector<Node*> newt;
				newt.resize(_tables.size() * 2, nullptr);

				for (int i = 0; i < _tables.size(); i++)
				{
					if (_tables[i])
					{
						//桶里有数据
						Node* cur = _tables[i];
						Node* next = nullptr;
						while (cur)
						{
							//放到新桶中
							size_t hashi = kov(cur->_data) % newt.size();
							if (newt[hashi] == nullptr)
							{
								next = cur->_pNext;	//记录下一个数据
								cur->_pNext = nullptr;
								newt[hashi] = cur;

								cur = next;
							}
							else
							{
								Node* ntcur = newt[hashi];
								while (ntcur->_pNext)
								{
									ntcur = ntcur->_pNext;
								}
								next = cur->_pNext;
								ntcur->_pNext = cur;
								cur->_pNext = nullptr;

								cur = next;

							}


						}

						_tables[i] = nullptr;
					}
				}
				swap(newt, _tables);

			}

			Node* newnode = new Node;
			newnode->_data = value;
			newnode->_pNext = nullptr;

			size_t hashi = kov(value) % _tables.size();
			if (_tables[hashi] == nullptr)
			{
				_tables[hashi] = newnode;
			}
			else
			{
				Node* cur = _tables[hashi];

				while (cur->_pNext)
				{
					cur = cur->_pNext;
				}

				cur->_pNext = newnode;


			}

			_n++;
			iterator nit(newnode, this);
			return make_pair(nit, true);

		}

		iterator Erase(iterator position)
		{
			Node* pos = position._pNode;

			size_t hashi = kov(pos->_data) % _tables.size();
			if (_tables[hashi] == nullptr)
			{
				//该桶无数据
				return iterator(nullptr, this);
			}
			else
			{
				Node* cur = _tables[hashi];
				if (cur == pos)
				{
					//释放的是该桶第一个结点,即_tables[hashi]
					if (cur->_pNext == nullptr)
					{
						delete cur;
						_n--;
						_tables[hashi] = nullptr;
						for (int i = hashi + 1; i < _tables.size(); i++)
						{
							//返回下一个结点
							if (_tables[i])
							{
								return iterator(_tables[i], this);
							}
						}

						return iterator(nullptr, this);
					}
					else
					{
						Node* pnext = pos->_pNext;
						delete pos;
						_n--;
						_tables[hashi] = pnext;

						return iterator(pnext, this);
					}
				}

				//pos不在_tables[hashi]的位置，查找pos是否在该桶中
				Node* prev = cur;
				cur = cur->_pNext;
				Node* next = cur;
				while (cur)
				{
					next = cur->_pNext;
					if (cur == pos)
					{
						prev->_pNext = next;
						delete cur;
						_n--;

						//返回下一个结点
						if (next)
						{
							return iterator(next, this);
						}
						else
						{
							for (int i = hashi + 1; i < _tables.size(); i++)
							{
								//返回下一个结点
								if (_tables[i])
								{
									return iterator(_tables[i], this);
								}
							}

							return iterator(nullptr, this);
						}
					}

					prev = cur;
					cur = cur->_pNext;
					if (cur)
						next = cur->_pNext;
				}

				//没找到
				return iterator(nullptr, this);
			}
		}

		size_t BucketCount()
		{
			size_t cnt = 0;
			for (int i = 0; i < _tables.size(); i++)
			{
				if (_tables[i])
				{
					cnt++;
				}
			}

			return cnt;
		}

		size_t BucketSize(K& key)
		{
			size_t hashi = key % _tables.size();
			Node* cur = _tables[hashi];
			size_t cnt = 0;

			while (cur)
			{
				cnt++;
				cur = cur->_pNext;
			}

			return cnt;
		}

	private:
		vector<Node*> _tables;
		size_t _n = 0;
	};

杯酒问苍天
关注
专栏目录
C++ 哈希
m0_61548909的博客
08-27 2831
在 C++98 中， STL 提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 $log_2N$，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11 中， STL 又提供了 4 个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，本文中只对unordered_map 和 unordered_set 进行介绍，unordered_multimap和
C++哈希
qq_53413129的博客
06-09 3766
unordered系列关联式容器 unordered_map unordered_map的文档介绍 unordered_set 底层结构 哈希概念 哈希冲突的解决 闭散列： 代码实现 哈希基本结构 插入 查找find 删除 仿函数的应用 开散列 基本结构 插入的实现 查找 删除 Unordered_set/Unordered_set对哈希的封装 封装代码框架： 哈希表的迭代器 【operator*和operator->】 operator++前置++ 迭代器
C++哈希详解
weixin_66400112的博客
06-08 2451
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素 时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即 O($log_2 N$)，搜索的效率取决于搜索过程中元素的比较次数。
C++ 哈希表
Han同学
02-26 3193
C++哈希表
c++哈希表
qq_60567866的博客
12-31 1387
在刷初级算法的字符串有好多关于哈希表的内容 所以作词笔记，强化哈希。 首先哈希表的作用是什么？它可以快速的查找。key-value值。 key值是唯一的。就例如一个统计某几人的身高。 如下是STL标准库map容器的实例。 map不允许容器中有重复key值元素 map<string, string> PersonMap; PersonMap["张三"] = "183"; PersonMap["张四"] = "186"; PersonMap["张五"] = "173"; PersonMap[
使用C++哈希表实现的学生信息管理系统
04-02
数据结构课程设计之——使用C++哈希表实现的学生信息管理系统。 编译器选择DevC++ 或者 VS2019都可，按照要求新建文件，运行即可。 一、程序的主要功能 程序分为四个模块： 1.建立哈希表：有三个功能（1）插入一个...
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
qq_61936886的博客
09-12 431
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1130
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 279
试除法求约数、约数个数、约数之和、最大公约数
深度优先算法，广度优先算法，hill climbing，贪心搜索，A*算法，启发式搜索算法是什么，比起一般搜索法算法有什么区别
mimo_mimo的博客
09-10 1162
A算法通过维护一个优先队列（通常是最小堆），并根据启发式函数（如g(n) + h(n)，其中g(n)是从起点到当前点的实际距离，h(n)是从当前点到目标点的估计距离）来评估节点的优先级。它从图的某个顶点V0开始，依次访问V0的各个未被访问过的邻接点，然后从这些邻接点出发，再依次访问它们的未被访问过的邻接点，直到图中所有已被访问过的顶点的邻接点都被访问到。它从当前的节点开始，和周围的邻居节点的值进行比较，如果当前节点不是最大的，就用最高的邻居节点来替换当前节点，从而实现向“山峰”的高处攀爬的目的。
C语言程序设计-练习篇
最新发布
2402_85207276的博客
09-14 935
·三角形的判断 ·使用指针打印数组内容 ·字符串逆序 ·计算求和 ·打印水仙花数
Codeforces Round 969 (Div. 2) C. Dora and C++ （裴蜀定理）
2302_79440616的博客
09-10 459
取模，这样就能够得到所有数的最简形式（可以当成是让所有数尽可能消去。所以在这时候我们就可以让输入的所有数都去对。那么在取模之后我们现在排序，得到的极差就是。可以想到使用同样是需要给出两个定值的。由于这里给出了a和b两个数，我们。的判断，因为不排除有这种情况存在。，那么这里我们还要进行一次。，这样我们会取到最优解。
leecode100题-双指针-三数之和
kian9one的博客
09-10 429
固定i，即可转换为寻找满足 nums[l]+nums[r]=−nums[i] 的三元组，因为不能包含重复的三元组，以下两个三元组只能取一个，而后我们再考虑其是否满足 nums[l]+nums[r]=−nums[i]。先对数组排序，设一非递减的数组示例和初始三指针位置及名字如下所示。不同的三元组是 [-1,0,1] 和 [-1,-1,2]。移动指针的时候，需要规避连续的重复元素。答案中不可以包含重复的三元组。，判断是否存在三元组。
拥塞控制算法为何失效，网络为何难以测量？
Netfilter
09-14 1955
所以你知道实验室仿真的宇宙第一算法为啥拉了吧，也就不用再问为什么部署了 bbr 却还不如 cubic 了吧，如果你还希望研发一个精准的，普适的端到端算法，我劝你改行去卖皮鞋，至少还有很多经理市场。这和上一篇说的测量系统容量的方法并不矛盾，因为对于网络传输系统而言，系统是动态变化的，在流量部署到系统上并开始传输时，没有全局视图，就不能指望全局公平，留下的 gap 是固有的，没法靠算法弥补。，超级经典的一篇论文，我推荐过不止一次，因此我本文不谈异构问题，说点别的，比如拓扑。对，就是要砸，因为我不干了。
代码随想录算法训练营day18|二叉树06
gyuhyhui的博客
09-10 788
示例 2: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 输出: 5 解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。那么我们来说一说，如果 root == q，或者 root == p，说明找到 q p ，则将其返回，这个返回值，后面在中节点的处理过程中会用到，那么中节点的处理逻辑，下面讲解。例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]
算法里面的离散化
admin_zbn的博客
09-11 894
离散化的主要目的是将连续的值或大范围的值映射到一个有限的集合中，以便进行高效的存储和处理。这通常通过对连续的数据进行排序、分组、或者映射来实现。离散化的关键是将原始的、可能是连续或无限范围的数据，转化为有限且可处理的编号或索引。这样不仅优化了存储空间，也提高了数据处理的效率。二、在算法中，“映射”是指将一个集合中的每个元素通过某种规则或函数转换为另一个集合中的元素的过程。这一概念广泛应用于数据处理、函数设计和数据结构中。
18068 选择排序
huang1xiao1sheng的博客
09-11 406
输入10个整数，编写一个实现对数组进行选择排序的函数 #include int sort(int a[], int n) { int i,j,k,tmp; for(i=0;i
Acwing 区间合并
qq_43060884的博客
09-14 965
区间合并，还在模拟吗？
DFS 算法：洛谷B3625迷宫寻路
Python_enjoy 是一个大帅哥！
09-07 1089
这永远不是最后一篇讲解算法的文章
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

杯酒问苍天

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值