【C++】哈希

于 2024-04-12 17:08:19 发布
阅读量840 收藏 22
点赞数 13
分类专栏： C++ 文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FZC206/article/details/137603383
版权

一、unordered系列容器

在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到logN，即最差情况下需要比较红黑树的高度次，当树中的节点非常常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到。在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同。

unordered_xxx系列与map和set容器的用法上几乎没有任何区别；
区别：

  1. unordered_xxx系列都是哈希表作为底层的，而map和set是用红黑树作为底层的
  2. unordered_xxx系列不排序，只去重
  3. unordered_xxx系列是单项迭代器，map和set是双向迭代器

二、unordered_set

在这里插入图片描述

unordered_set是一种容器，它以无特定顺序的方式存储唯一的元素，并允许根据元素的值快速检索各个元素。
在unordered_set中，元素的值同时也是它的键，唯一标识该元素。键是不可变的，因此，unordered_set中的元素一旦放入容器后就不能被修改，不过可以插入和删除。
在内部，unordered_set中的元素不按任何特定顺序排序，而是根据它们的哈希值组织成桶，以便通过它们的值（平均具有恒定的平均时间复杂度）直接快速访问各个元素。
对于通过键访问单个元素，unordered_set容器比set容器更快，尽管对于通过子集范围迭代它们通常效率较低。
容器中的迭代器是单向迭代器。

void hash_test()
{
	unordered_set<int> s;
	//set<int> s;

	s.insert(2);
	s.insert(4);
	s.insert(9);
	s.insert(1);
	s.insert(2);
	s.insert(3);

	for (auto e : s)
	{
		cout << e << " ";
	}
}

在这里插入图片描述

三、unordered_map

在这里插入图片描述

无序映射是关联容器，存储由键值和映射值组合形成的元素，并允许根据它们的键快速检索各个元素。
在unordered_map中，键值通常用于唯一标识元素，而映射值是与该键关联的对象的内容。键和映射值的类型可以不同。
在内部，unordered_map中的元素不根据它们的键或映射值按任何特定顺序排序，而是根据它们的哈希值组织成桶，以便通过它们的键值直接快速访问各个元素（平均具有恒定的平均时间复杂度）。
对于通过键访问单个元素，unordered_map容器比map容器更快，尽管对于通过子集范围迭代它们通常效率较低。
无序映射实现了直接访问运算符（operator[]），允许使用键值作为参数直接访问映射值。
容器中的迭代器是单向迭代器。

void hash_test2()
{
	unordered_map<string, string> dict;
	dict["insert"] = "插入";
	dict["sort"] = "排序";
	dict["delete"] = "删除";
	dict["string"] = "字符串";
	dict["insert"] = "xxxxx";
	dict.insert(make_pair("iterator", "迭代器"));
	unordered_map<string, string>::iterator umit = dict.begin();
	while (umit != dict.end())
	{
		cout << umit->first << ":" << umit->second << endl;
		umit++;
	}
	cout << endl;
}

在这里插入图片描述

四、set与unordered_set比较

void test_op()
{
	int n = 10000000;
	vector<int> v;
	v.reserve(n);
	srand(time(0));
	for (int i = 0; i < n; i++)
	{
		//v.push_back(rand());//无序数列
		//v.push_back(rand() + i);//无序数列+减少重复值
		v.push_back(i);//有序数列
	}

	size_t begin1 = clock();
	set<int> s;
	for (auto e : v)
		s.insert(e);
	size_t end1 = clock();

	size_t begin2 = clock();
	unordered_set<int> us;
	for (auto e : v)
		us.insert(e);
	size_t end2 = clock();
	cout << s.size() << endl; cout << us.size() << endl;
	cout << "set.insert: " << end1 - begin1 << endl;
	cout << "ordered_set.insert: " << end2 - begin2 << endl;

	size_t begin3 = clock();
	for (auto e : v)
		s.find(e);
	size_t end3 = clock();
	size_t begin4 = clock();
	for (auto e : v)
		us.find(e);
	size_t end4 = clock();
	cout << "set.find: " << end3 - begin3 << endl;
	cout << "ordered_set.find: " << end4 - begin4 << endl;

	size_t begin5 = clock();
	for (auto e : v)
		s.erase(e);
	size_t end5 = clock();
	size_t begin6 = clock();
	for (auto e : v)
		us.erase(e);
	size_t end6 = clock();
	cout << "set.erase: " << end5 - begin5 << endl;
	cout << "ordered_set.erase: " << end6 - begin6 << endl;
}

在这里插入图片描述
在这里插入图片描述
可见，unordered_set优势显而易见。

五、查找比较

  1. 暴力
    时间复杂度是O(N)

  2. 二分
    时间复杂度(logN)

  3. 平衡树
    时间复杂度(logN)

  4. 哈希

1.闭散列—开放定值法

a.线性探测
b.二次探测

2.开散列–拉链法/哈希桶

六、哈希

闭散列

温馨提醒：这里有个线性探测和二次探测，两者代码为继承关系，冗余度较高，请注意差别

namespace fzc
{
	enum State
	{
		EMPTY,
		EXIST,
		DELETE
	};

	template<class K, class V>
	struct HashData
	{
		pair<K, V> _kv;
		State _state = EMPTY;
	};

	template<class K, class V>
	class HashTable
	{
	public:
		bool Insert(const pair<K, V>& kv)
		{
			//负载因子到了就扩容
			if (_tables.size() == 0 || 10 * _size / _tables.size() >= 7)//扩容
			{
				size_t newSize = _size == 0 ? 10 : _tables.size() * 2;
				HashTable<K, V> newTable;
				newTable._tables.resize(newSize);
				for (auto e : _tables)
				{
					if (e._state == EXIST)
					{
						newTable.Insert(e._kv);
					}
				}
				_tables.swap(newTable._tables);
			}
			size_t hashi = kv.first % _tables.size();
			//线性探测
			while (_tables[hashi]._state == EXIST)
			{
				hashi++;
				hashi %= _tables.size();
			}
			_tables[hashi]._kv = kv;
			_tables[hashi]._state = EXIST;
			++_size;
			return true;
		}
	private:
		//vector<pair<K, V>> _tables;
		vector<HashData<K, V>> _tables;
		size_t _size = 0;//存储的有效数据个数
	};

	void testHT1()
	{
		HashTable<int, int> HT;
		HT.Insert(make_pair(1, 2));
		HT.Insert(make_pair(7, 2));
		HT.Insert(make_pair(6, 2));
		HT.Insert(make_pair(5, 2));
		HT.Insert(make_pair(2, 2));
		HT.Insert(make_pair(11, 2));
		HT.Insert(make_pair(3, 2));
		HT.Insert(make_pair(43, 2));
		HT.Insert(make_pair(23, 2));
		HT.Insert(make_pair(13, 2));
	}
}

看下来的代码

namespace fzc
{
	enum State
	{
		EMPTY,
		EXIST,
		DELETE
	};

	template<class K, class V>
	struct HashData
	{
		pair<K, V> _kv;
		State _state = EMPTY;
	};

	template <class K>
	struct HashFunc
	{

	};

	template<class K, class V>
	class HashTable
	{
	public:
		bool Insert(const pair<K, V>& kv)
		{
			if (Find(kv.first))
				return false;

			//负载因子到了就扩容
			if (_tables.size() == 0 || 10 * _size / _tables.size() >= 7)//扩容
			{
				size_t newSize = _size == 0 ? 10 : _tables.size() * 2;
				HashTable<K, V> newTable;
				newTable._tables.resize(newSize);
				for (auto e : _tables)
				{
					if (e._state == EXIST)
					{
						newTable.Insert(e._kv);
					}
				}
				_tables.swap(newTable._tables);
			}
			size_t hashi = kv.first % _tables.size();
			//线性探测
			while (_tables[hashi]._state == EXIST)
			{
				hashi++;
				hashi %= _tables.size();
			}
			_tables[hashi]._kv = kv;
			_tables[hashi]._state = EXIST;
			++_size;
			return true;
		}
		bool Erase(const K& key)
		{
			HashData<K, V>* ret = Find(key);
			if (ret)
			{
				ret->_state = DELETE;
				--_size;
				return true;
			}
			return false;
		}
		HashData<K, V>* Find(const K& key)
		{
			if (_size == 0)
				return nullptr;

			size_t hashi = key % _tables.size();
			size_t start = hashi;
			while (_tables[hashi]._state != EMPTY)
			{
				if (_tables[hashi]._state != DELETE && _tables[hashi]._kv.first == key)
				{
					return &_tables[hashi];
				}
				hashi++;
				hashi %= _tables.size();

				if (hashi == start)//预防重复查找
					break;
			}
			return nullptr;
		}
		void Print()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				if (_tables[i]._state == EXIST)
				{
					printf("[%d:%d] ", i, _tables[i]._kv.first);
				}
				else
				{
					printf("[%d:*] ", i);
				}
			}
			cout << endl;
		}
	private:
		//vector<pair<K, V>> _tables;
		vector<HashData<K, V>> _tables;//_tables.size()表示哈希表的大小
		size_t _size = 0;//存储的有效数据个数
	};

	void testHT1()
	{
		HashTable<int, int> HT;
		int a[] = { 1,7,6,5,2,11,3,43,23,13 };
		for (auto& e : a)
		{
			HT.Insert(make_pair(e, e));
		}

		HT.Erase(13);
		cout << HT.Find(23) << endl;
		cout << HT.Find(13) << endl;
		HT.Print();

		HT.Insert(make_pair(-2, -2));
		HT.Print();
	}
	void testHT2()
	{
		string arr[] = { "梨子","苹果","猕猴桃","桃" ,"梨子","苹果", "猕猴桃","猕猴桃","猕猴桃","梨子","猕猴桃" };
		HashTable<string, int> HT;
		for (auto& e : arr)
		{
			auto ptr = HT.Find(e);
			if (ptr)
			{
				ptr->_kv.second++;
			}
			else
			{
				HT.Insert(make_pair(e, 1));
			}
		}
	}
}

string类型无法进行取模运算，去看STL库：
在这里插入图片描述

hash< Key >是一个仿函数；来处理；
将key转化为无符号的类型，让其进行布尔值比较；

在这里插入图片描述

可能出现 abcd bcda 等顺序不同，但字母（或ASCII码）及其数量相同的字符串

看大佬的处理方法：
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
完美解决；这些思想都与数学算法思想有关，感兴趣伙伴可了解一下；
完整代码：

namespace fzc
{
	enum State
	{
		EMPTY,
		EXIST,
		DELETE
	};

	template<class K, class V>
	struct HashData
	{
		pair<K, V> _kv;
		State _state = EMPTY;
	};

	//仿函数
	template <class K>
	struct HashFunc
	{
		size_t operator()(const K& key)
		{
			return (size_t)key;
		}
	};

	//string类型属于常见类型，故而可做特化处理
	template <>
	struct HashFunc<string>//特化
	{
		//可能出现 abcd   bcda 等顺序不同，但字母（或ASCII码）及其数量相同的字符串，
		//BKDR 思想
		size_t operator()(const string& key)
		{
			size_t res = 0;
			for (auto e : key)
			{
				 res *= 131;
				res += e;
			}
			return res;
		}
	};
	//struct HashFuncString
	//{
	//	size_t operator()(const string& key)
	//	{
	//		size_t res = 0;
	//		for (auto e : key)
	//		{
	//			res += e;
	//		}
	//		return res;
	//	}
	//};

	template<class K, class V,class Hash = HashFunc<K>>
	class HashTable
	{
	public:
		bool Insert(const pair<K, V>& kv)
		{
			if (Find(kv.first))
				return false;

			//负载因子到了就扩容
			if (_tables.size() == 0 || 10 * _size / _tables.size() >= 7)//扩容
			{
				size_t newSize = _size == 0 ? 10 : _tables.size() * 2;
				HashTable<K, V,Hash> newHashTable;
				newHashTable._tables.resize(newSize);
				for (const auto& e : _tables)
				{
					if (e._state == EXIST)
					{
						newHashTable.Insert(e._kv);
					}
				}
				_tables.swap(newHashTable._tables);
			}
			Hash hash;
			size_t hashi = hash(kv.first) % _tables.size();
			//线性探测
			while (_tables[hashi]._state == EXIST)
			{
				hashi++;
				hashi %= _tables.size();
			}
			_tables[hashi]._kv = kv;
			_tables[hashi]._state = EXIST;
			++_size;
			return true;
		}
		bool Erase(const K& key)
		{
			HashData<K, V>* ret = Find(key);
			if (ret)
			{
				ret->_state = DELETE;
				--_size;
				return true;
			}
			return false;
		}
		HashData<K, V>* Find(const K& key)
		{
			if (_size == 0)
				return nullptr;
			Hash hash;
			size_t hashi = hash(key) % _tables.size();
			size_t start = hashi;
			while (_tables[hashi]._state != EMPTY)
			{
				if (_tables[hashi]._state != DELETE && _tables[hashi]._kv.first == key)
				{
					return &_tables[hashi];
				}
				hashi++;
				hashi %= _tables.size();

				if (hashi == start)//预防重复查找
					break;
			}
			return nullptr;
		}
		void Print()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				if (_tables[i]._state == EXIST)
				{
					//printf("[%d:%d] ", i, _tables[i]._kv.first);
					cout << i << "[" << _tables[i]._kv.first << ":" << _tables[i]._kv.second << "]";
				}
				else
				{
					//printf("[%d:*] ", i);
					cout << i << "[" << _tables[i]._kv.first << ":" << _tables[i]._kv.second << "]";
				}
			}
			cout << endl;
		}
	private:
		//vector<pair<K, V>> _tables;
		vector<HashData<K, V>> _tables;//_tables.size()表示哈希表的大小
		size_t _size = 0;//存储的有效数据个数
	};

	void testHT1()
	{
		HashTable<int, int> HT;
		int a[] = { 1,7,6,5,2,11,3,43,23,13 };
		for (auto& e : a)
		{
			HT.Insert(make_pair(e, e));
		}

		HT.Erase(13);
		cout << HT.Find(23) << endl;
		cout << HT.Find(13) << endl;
		HT.Print();

		HT.Insert(make_pair(-2, -2));
		HT.Print();
	}
	void testHT2()
	{
		string arr[] = { "梨子","苹果","猕猴桃","桃" ,"梨子","苹果", "猕猴桃","猕猴桃","猕猴桃","梨子","猕猴桃" };
		//HashTable<string, int, HashFuncString> HT;
		HashTable<string, int> HT;
		for (auto& e : arr)
		{
			auto ptr = HT.Find(e);
			if (ptr)
			{
				ptr->_kv.second++;
			}
			else
			{
				HT.Insert(make_pair(e, 1));
			}
		}
		HT.Print();
	}
	void testHT3()
	{
		HashFunc<string> hash;
		cout << hash("abcd") << endl;
		cout << hash("bcda") << endl;
		cout << hash("acbd") << endl;
	}

}

以上为线性测试

“二次探测”
对比：
在这里插入图片描述
还是没有从本质上解决问题，仍为占用式（自身位置被占用，采用别人的），只是在应对集中式的数据时处理有所优化 ；
线性探测：让其挨着占用；
二次探测 :本质是让其跳跃占用
以上两种探测法均属于闭散列；下来看用开散列

采用开散列

拉链法
在这里插入图片描述
stlstl中负载因子为1

这里将其中可能存在的问题均在代码注释之中，若有小伙伴有问题评论区见

namespace hash_bucket
{
	template<class K, class V>
	struct HashData
	{
		pair<K, V> _kv;
		struct HashData* next = nullptr;
		HashData(const pair<K, V>& kv)
			:_kv(kv)
		{}
	};

	//仿函数:这里直接用开散列仿函数
	template <class K>
	struct HashFunc
	{
		size_t operator()(const K& key)
		{
			return (size_t)key;
		}
	};
	template <>
	struct HashFunc<string>//特化
	{
		size_t operator()(const string& key)
		{
			size_t res = 0;
			for (auto e : key)
			{
				res *= 131;
				res += e;
			}
			return res;
		}
	};

	template<class K, class V, class Hash = HashFunc<K>>	//
	class HashTable
	{
		typedef HashData<K, V> Node;
	public:
		HashTable()
			:_size(0)
			,_tables(10, nullptr)
		{}
		~HashTable()//这里的析构函数得自己添加，否则只会析构哈希表，导致节点数据没有被释放
		{
			//这里的操作和底下的打印有点像
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->next;
					delete cur;
					cur = next;
				}
				_tables[i] = nullptr;
			}
		}
		bool Insert(const pair<K, V>& kv)
		{
			if (Find(kv.first))
				return false;

			Hash hash;

			//负载因子到 1 就扩容
			if (_size == _tables.size())//扩容
			{
				size_t newSize = _tables.size() * 2;
				vector<Node*> newTables(newSize, nullptr);
				//这里为了减少调用，不像开散列那样采用复用insert的形式，而是直接将原表中的节点拿下来直接用
				//而且复用insert的时候会涉及空间的申请释放问题（申请新节点，将旧节点的值给新节点，然后释放新旧结点）
				size_t hashi = 0;
				//旧表数据移到新表
				//特别注意：一个一个数据移动，不可一串一串移动，那样的话会造成映射位置错误，最后使其数据不能被正常找到
				for (size_t i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->next;
						hashi = hash(cur->_kv.first) % newTables.size();
						cur->next = newTables[hashi];
						newTables[hashi] = cur;
						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newTables);
			}

			size_t hashi = hash(kv.first) % _tables.size();
			//头插
			Node* old = _tables[hashi];
			_tables[hashi] = new Node(kv);
			_tables[hashi]->next = old;
			_size++;
			return true;
		}
		Node* Find(const K& key)
		{
			if (_size == 0)
				return nullptr;

			Hash hash;
			size_t hashi = hash(key) % _tables.size();
			Node* cur = nullptr;
			for (size_t i = 0; i < _tables.size(); i++)
			{
				cur = _tables[i];
				while (cur)
				{
					if (cur->_kv.first == key)
					{
						return cur;
					}
					cur = cur->next;
				}
			}
			return nullptr;
		}
		void Print()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					cout << "[" << cur->_kv.first << ": " << cur->_kv.second << "]-->";
					cur = cur->next;
				}
			}
			cout << endl;
		}
		bool Erase(const K& key)
		{
			//单链表的删除得知道前一个节点地址，故在这里不在复用Find()函数，否则找不到删除节点的前驱结点
			//Node* ret = Find(key);
			//if (ret)
			//{
			//	Node* next = ret->next;
			//	delete ret;

			//	--_size;
			//	return true;
			//}

			Hash hash;
			size_t hashi = hash(key) % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (prev)
					{
						prev->next = cur->next;
					}
					else
					{
						_tables[hashi] = cur->next;

					}
					delete cur;
					cur = nullptr;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->next;
				}
			}
			return false;
		}
	private:
		size_t _size = 0;//有效数据个数
		vector<Node*> _tables;
	};

	void testHT1()
	{
		HashTable<int, int> HT;
		int a[] = { 1,7,6,5,2,11,3,43,23,13,54,36 };
		for (auto& e : a)
		{
			HT.Insert(make_pair(e, e));
		}
		HT.Print();

		HT.Erase(13);
		cout << HT.Find(23) << endl;
		cout << HT.Find(13) << endl;
		HT.Print();

		HT.Insert(make_pair(-2, -2));
		HT.Print();
	}
	void testHT2()
	{
		string arr[] = { "梨子","苹果","猕猴桃","桃" ,"梨子","苹果", "猕猴桃","猕猴桃","猕猴桃","梨子","猕猴桃" };
		//HashTable<string, int, HashFuncString> HT;
		HashTable<string, int> HT;
		for (auto& e : arr)
		{
			auto ptr = HT.Find(e);
			if (ptr)
			{
				ptr->_kv.second++;
			}
			else
			{
				HT.Insert(make_pair(e, 1));
			}
		}
		HT.Print();
	}
}

学完不难发现，这里比map和set简单了许多，原来传说中的哈希不过尔尔、哈哈哈哈哈（小小嘚瑟一下）；

风里画沙_0
关注
  • 13
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C++ 哈希
m0_61548909的博客
08-27 2769
在 C++98 中， STL 提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 $log_2N$，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11 中， STL 又提供了 4 个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，本文中只对unordered_map 和 unordered_set 进行介绍，unordered_multimap和
C++哈希
qq_53413129的博客
06-09 3248
unordered系列关联式容器 unordered_map unordered_map的文档介绍 unordered_set 底层结构 哈希概念 哈希冲突的解决 闭散列： 代码实现 哈希基本结构 插入 查找find 删除 仿函数的应用 开散列 基本结构 插入的实现 查找 删除 Unordered_set/Unordered_set对哈希的封装 封装代码框架： 哈希表的迭代器 【operator*和operator->】 operator++前置++ 迭代器
C++ 哈希表
Han同学
02-26 2477
C++哈希表
C++哈希表的实现
Wzs040810的博客
12-23 5496
C++哈希表的实现
使用C++哈希表实现的学生信息管理系统
04-02
数据结构课程设计之——使用C++哈希表实现的学生信息管理系统。 编译器选择DevC++ 或者 VS2019都可，按照要求新建文件，运行即可。 一、程序的主要功能 程序分为四个模块： 1.建立哈希表：有三个功能（1）插入一个...
C++哈希表实现.zip
08-20
在C++中，虽然标准库没有直接提供哈希表，但我们可以通过自定义结构来实现。本压缩包包含两个文件：`HashTest.cpp` 和 `Hashtable.h`，它们展示了如何用C++来构建一个简单的哈希表。 在`Hashtable.h`中，我们通常会...
C++哈希表与六子棋的应用学习代码
03-01
c 哈希表 六子棋（Gomoku，又称为五子棋或连珠）是一个两人对战的策略游戏。在这个游戏中，玩家轮流在棋盘上放置棋子，目标是首先形成一条连续的五个或更多同色棋子的直线（横、竖、斜均可）。 下面是一个简单的六...
哈希表de 设计.rar_c++ 哈希表_哈希_哈希 VC_哈希表
09-23
在C++中，哈希表通常通过自定义实现或使用标准库中的`unordered_map`来实现。本文将深入探讨哈希表的设计原理、工作方式以及在C++中的应用。 哈希表的核心思想是通过哈希函数将键（key）映射到数组的索引位置，以...
c++的哈希表hash
03-18
c
哈希代码C++
05-04
在C++编程中，哈希表（Hash Table）是通过哈希函数将键（Key）映射到一个桶（Bucket）中的数据结构。这种映射关系使得我们可以快速定位到目标数据，通常时间复杂度为O(1)。 哈希函数是哈希表的关键组成部分，它接受...
c++中的哈希表hash
03-18
c
C++哈希算法的实现
01-10
综上所述，C++哈希表的实现涉及哈希函数的设计、冲突处理策略的选择以及相应的插入、查找和删除操作。理解这些概念并能够灵活应用，对于提升C++编程的效率和解决问题的能力至关重要。在实际开发中，可以根据具体需求...
C++ 哈希表 班级人名查找
11-13
针对本班的人名设计一个杂凑表，数据表的长度为50~80个记录；分析平均查找长度，完成相应的建表和查表程序，设计直观的界面显示杂凑表的内容。 基本要求： 人名用汉语拼音表示，例如“苏志勇”表示为“su zhiyong”...
C++哈希表使用的好文章-Hash_Map
05-17
哈希表，作为一种高效的数据结构，它通过哈希函数将数据映射到特定的位置，从而实现快速的查找、插入和删除操作。C++中的`hash_map`虽然未被正式纳入标准模板库(STL)，但在很多STL实现中都有提供。`hash_map`的优势...
哈希表-使用C++实现的哈希表-HashTable.zip
03-04
下面将详细介绍哈希表的工作原理、哈希冲突解决方法以及如何使用C++进行实现。 1. **哈希表工作原理** 哈希表的核心是哈希函数，它将键转化为数组索引。理想的哈希函数能够均匀地分布键值，使得每个键都有可能映射...
C++哈希模板（基于邻接表） 散列
08-03
在这个C++哈希模板中，采用了链地址法，即当多个键映射到同一个索引时，用链表连接这些键对应的值，形成邻接表结构。 邻接表是一种用于表示图的数据结构，它由顶点集合和边集合组成。在这里，我们将每个索引看作一...
哈希表C++代码实现
05-29
下面是一个简单的C++哈希表实现，使用了链地址法处理冲突： ```cpp #include #include template , typename Value> class HashTable { private: static const int TABLE_SIZE = 100; // 哈希表大小 std::list,...
一个c++实现的哈希表类-C++文档类资源
03-23
在程序中我们对关键字key应用散列函数H(key)来判断关键字key是否在散列表中，即计算H(key)的值，H(key)值确定所存数据在散列表中的位置。这样一个数据元素的地址是通过函数来计算的，所以数据元素并不需要按照特定的...
MD5哈希算法的C++实现（兼容大端字节序的CPU）
最新发布
04-30
MD5哈希算法的C++实现（兼容大端字节序的CPU） 测试代码 #include #include #include"md5.c" int main() { using namespace std; u8 $finalHash[16] = {}; const char* str = "a"; //调用MD5 int ret = ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值