[C++] 哈希结构

最新推荐文章于 2024-09-24 10:46:23 发布
最新推荐文章于 2024-09-24 10:46:23 发布
阅读量898 收藏 3
点赞数 3
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42351880/article/details/98121700
版权

哈希

小引

STL中的unordered系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构，它是一种甚至优于红黑树的结构，可以使用O（1）的时间复杂度查找或者修改元素，而红黑树最优也是O（logN）。

但是哈希结构也有他的局限之处：哈希冲突，概念及解决方法我们在本篇博客中会讲解。

哈希概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(lgN)，搜索的效率取决于搜索过程中元素的比较次数。

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。
如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素，这就是哈希结构。

当向该结构中：

  • 插入元素
    根据待插入元素的key值，通过此函数计算出该元素的存储位置并按此位置进行存放。
  • 搜索元素
    对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。

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

例如：数据集合{1，7，6，4，5，9}
哈希函数设置为：hash(key) = key % capacity;（ capacity为存储元素底层空间总的大小）

存储情况如下图：
在这里插入图片描述

用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快。

  • 但如果插入了大于capacity的元素，如77是否就无法正常运行了？
  • 是的，使用这种简单的哈希函数设计出现这样的问题就无法应对了，因为出现了哈希冲突。

哈希冲突

不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。

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

  • 哈希函数设计原则：
    哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间。哈希函数计算出来的地址能均匀分布在整个空间中（尽量避免冲突）。

哈希函数

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

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

  3. 平方取中法
    假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址； 再比如关键字为
    4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址 平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况

  4. 折叠法
    折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。
    折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况

  5. 随机数法
    选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。
    通常应用于关键字长度不等时采用此法

  6. 数学分析法
    设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。例如：
    假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前7位都是相同的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现 冲突，还可以对抽取出来的数字进行反转(如1234改成4321)、右环位移(如1234改成4123)、左环移位、前两数与后两数叠加(如1234改成12+34=46)等方法。
    数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况

【小结】哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突。

哈希冲突的解决方案

1. 闭散列

闭散列也叫开放定址法。

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

线性探测

比如现在需要插入元素44，先通过哈希函数计算哈希地址，hashAddr为4，因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。

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

  1. 【插入】
    插入通过哈希函数获取待插入元素在哈希表中的位置。
    如果该位置中没有元素则直接插入新元素。
    如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素。
    在这里插入图片描述
  2. 【删除】
    删除采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。
    （比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素，设置状态值的方法。）
enum State{
	EMPTY,		//此位置为 空
	EXIST,		//此位置为 已有元素 
	DELETE		//此位置为 已经删除
};

线性探测的实现

// 注意：假如实现的哈希表中元素唯一，即key相同的元素不再进行插入
// 为了实现简单，此哈希表中我们将比较直接与元素绑定在一起

enum State {
	EMPTY,		//此位置为 空
	EXIST,		//此位置为 已有元素 
	DELETE		//此位置为 已经删除
};
template<class K, class V>
class HashTable{
	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;
	}
	bool Insert(const pair<K, V>& val){
		// 检测哈希表底层空间是否充足
		// _CheckCapacity();
		size_t hashAddr = HashFunc(key);
		// size_t startAddr = hashAddr;
		while (_ht[hashAddr]._state != EMPTY){
			if (_ht[hashAddr]._state == EXIST && _ht[hashAddr]._val.first == key)
				return false;
			hashAddr++;
			if (hashAddr == _ht.capacity())
				hashAddr = 0;
			/*
				// 转一圈也没有找到，注意：动态哈希表该种情况可以不用考虑，哈希表中元素个数到达
			   一定的数量，哈希冲突概率会增大，需要扩容来降低哈希冲突，因此哈希表中元素是不会存满的
				if(hashAddr == startAddr)
				return false;
			*/
		}

		// 插入元素
		_ht[hashAddr]._state = EXIST;
		_ht[hashAddr]._val = val;
		_size++;
		return true;
	}
	int Find(const K& key){
		size_t hashAddr = HashFunc(key);
		while (_ht[hashAddr]._state != EMPTY){
			if (_ht[hashAddr]._state == EXIST && _ht[hashAddr]._val.first == key)
				return hashAddr;

			hashAddr++;
		}
		return hashAddr;
	}
	bool Erase(const K& key){
		int index = Find(key);
		if (index != -1){
			_ht[index]._state = DELETE;
			_size--;
			return true;
		}
		return false;
	}
private:
	size_t HashFunc(const K& key){
		return key % _ht.capacity();		//除留余数法，闭散列的核心，也是局限性所在
									//因为必须给定一个整型家族的key值，如果传入字符串就无法判断
	}
private:
	vector<Elem> _ht;
	size_t _size;
};

上述哈希表还存在以下的缺陷：

  1. 只能存储key为整型的元素，其他类型无法解决，例如string对象。
    【解决方案】： 构造一个仿函数，重载operator()对非整型元素进行转化即可。
//仿函数
template<class K>
struct HashFunc{		
	const K& operator()(const K& key){
		return key;
	}
};


//针对字符串key值的【模板特化】
template<>
struct HashFunc<string>{	
	size_t BKDRHash(const char* str){
		size_t hash = 0;
		while (*str){
			hash = hash * 131 + *str;
			++str;
		}
		return hash;
	}
	size_t operator()(const string& s){
		return BKDRHash(s.c_str());
	}
};

为了实现简单，此哈希表中我们将比较直接与元素绑定在一起

template<class K, class V, class HF>
class HashTable{
	 // ……
private:
size_t HashFunc(const K& key){
	return HF()(key)%_ht.capacity();
}
  1. 除留余数法，最好对一个素数取模，每次快速取一个类似两倍关系的素数又是一个问题。
    【解决方案】：给定一个素数表查找算法即可，获取到下一个素数、
const int PRIMECOUNT = 28;

const size_t primeList[PRIMECOUNT] ={
	// ul： unsigned long
	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
};

size_t GetNextPrime(size_t prime){
	size_t i = 0;
	for (; i < PRIMECOUNT; ++i){
		if (primeList[i] > prime)
			return primeList[i];
	}
	return primeList[i];
}
  1. 增容时机，如何增容还需要另外考虑。
    （载荷因子 = 表中元素个数 / 表长度）
    【方案】：对于开放定址法，载荷因子应控制在0.7 ~ 0.8以下，超过就需要增容。

线性探测的优缺点分析

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

线性探测的缺点的优化方案为另一种方法：二次探测。

二次探测

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就
是挨着往后逐个去找。
因此二次探测为了避免该问题，找下一个空位置的方法为： A(i)= (A(0) + i2 ) % m或者：A(i)= (A(0) - i2 ) % m。其中：i = 1,2,3…

是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小。

研究表明：
当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装
满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容。

因此：闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

闭散列代码整合

namespace closehash{		//闭散列
	enum State{		//三种状态
		EXIST,
		EMPTY,
		DELETE,
	};

	template<class T>
	struct HashStruct{
		T _v;			
		State _state;
	};

	template<class K, class T>
	class HashTable{
		typedef HashStruct<T> HashStruct;
	public:
		bool Insert(const T& v){
			// 1.除0问题
			// 2.数据映射关系打乱
			if (_table.size() == 0 || 10 * _num / _table.size() >= 7){
				size_t newsize = _table.size() == 0 ? 10 : _table.size() * 2;
				/*	vector<HashStruct> newtable;
					newtable.resize(newsize);
					for (size_t i = 0; i < _table; i++)
					{
						if (_table[i]._state == EXIST)
						{}
					}
				*/
				HashTable<K, T> newht;
				newht._table.resize(newsize);
				for (size_t i = 0; i < newht._table.size(); ++i){
					newht._table[i]._state = EMPTY;
				}

				for (size_t i = 0; i < _table.size(); ++i){
					if (_table[i]._state == EXIST){
						newht.Insert(_table[i]._v);
					}
				}
				_table.swap(newht._table);
			}

			/*
			 *	1. 线性探测
			 *
			 */
			//size_t index = v % _table.size();
			//while (_table[index]._state == EXIST){
			//	if (_table[index]._v == v){
			//		return false;
			//	}

			//	++index;
			//	if (index == _table.size())
			//		index = 0;
			//}


			//2. 二次探测
			size_t start = v % _table.size();
			size_t index = start;
			size_t i = 1;
			while (_table[index]._state == EXIST){
				if (_table[index]._v == v){
					return false;
				}

				index = start + i*i;
				index %= _table.size();
				++i;
			}
			_table[index]._v = v;
			_table[index]._state = EXIST;
			_num++;

			return true;
		}

		HashStruct* Find(const K& k){
			if (_table.size() == 0)
				return nullptr;

			size_t index = k % _table.size();
			while (_table[index]._state != EMPTY){
				if (_table[index]._v == k && _table[index]._state == EXIST){
					return &_table[index];
				}

				++index;
				if (index == _table.size()){
					index = 0;
				}
			}

			return nullptr;
		}

		bool Erase(const K& k){
			HashStruct* ret = Find(k);
			if (ret == nullptr){
				return false;
			}
			else{
				ret->_state = DELETE;
				--_num;
				return true;
			}
		}

	private:
	
		//线性存储所需的成员变量：
		//HashStruct* _table;
		//size_t _size;
		//size_t _capacity;
		
		vector<HashStruct> _table;	//链式结构
		size_t _num = 0;		// 映射存储的数据个数
	};

	void TestHashTable(){
		//HashTable<int, int> s;
		//s.Insert(5);
		//s.Insert(3);
		//s.Insert(2);
		//s.Insert(12);
		//s.Insert(22);
		//s.Insert(9);
		//s.Insert(8);
		//s.Insert(7);

		HashTable<int, int> s;
		s.Insert(2);
		s.Insert(12);
		s.Insert(22);
		s.Insert(32);
	}
}

2. 开散列【优】

概念

开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶（哈希桶），各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
在这里插入图片描述
从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。

开散列的代码实现

namespace hashbucket{		//哈希桶
	template<class T>
	struct HashNode{
		HashNode<T>* _next;	//使用单向链表，正好符合哈希结构只有正向迭代器，无反向迭代器rbegin()...
		T _v;
		
		HashNode(const T& t)
			:_v(t)
			, _next(nullptr)
		{}
	};

	template<class K, class T, class KeyOfValue, class HF>
	class HashTable;		//前置声明，防止编译发现未定义的类型而无法通过

	template<class K, class T, class KeyOfValue, class HF>
	struct __HTIterator{
		typedef HashNode<T> Node;
		typedef __HTIterator<K, T, KeyOfValue, HF> Self;
		Node* _node;
		HashTable<K, T, KeyOfValue, HF>* _pht;

		__HTIterator(Node* node, HashTable<K, T, KeyOfValue, HF>* pht)
			:_node(node)
			, _pht(pht)
		{}

		T& operator*(){
			return _node->_v;
		}

		T* operator->(){
			return &(operator*());
		}

		// ++it
		Self& operator++(){
			if (_node->_next){
				_node = _node->_next;
			}
			else{
				KeyOfValue kov;
				size_t index = _pht->HashFunc(kov(_node->_v), _pht->_table.size());
				++index;
				while (index < _pht->_table.size()){
					if (_pht->_table[index]){
						_node = _pht->_table[index];
						break;
					}
					else{
						++index;
					}
				}

				// 所有桶走完了，置为nullptr表示end()的位置
				if (index == _pht->_table.size()){
					_node = nullptr;
				}
			}

			return *this;
		}

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

	template<class K, class T, class KeyOfValue, class HF>
	class HashTable{
		typedef HashNode<T> Node;

		//friend struct __HTIterator<K, T, KeyOfValue, HF>;
		template<class K, class T, class KeyOfValue, class HF>
		friend struct __HTIterator;
	public:
		typedef __HTIterator<K, T, KeyOfValue, HF> iterator;
		iterator begin(){
			if (_num == 0){
				return end();
			}

			for (size_t i = 0; i < _table.size(); ++i){
				if (_table[i] != nullptr){
					return iterator(_table[i], this);
				}
			}

			return end();
		}

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

		pair<iterator, bool> Insert(const T& v){
			KeyOfValue kov;
			// 增容 load factor == 1
			if (_table.size() == _num){
				size_t newsize = _table.size() == 0 ? 10 : _table.size() * 2;
				vector<Node*> newtable;
				newtable.resize(newsize);

				// 挪动旧表数据到新表计算新的位置
				for (size_t i = 0; i < _table.size(); ++i){
					Node* cur = _table[i];
					while (cur){
						Node* next = cur->_next;

						size_t index = HashFunc(kov(cur->_v), newtable.size());
						cur->_next = newtable[index];
						newtable[index] = cur;

						cur = next;
					}

					_table[i] = nullptr;
				}

				newtable.swap(_table);
			}

			size_t index = HashFunc(kov(v), _table.size());
			Node* cur = _table[index];
			while (cur){
				if (kov(cur->_v) == kov(v)){
					return make_pair(iterator(cur, this), false);
				}

				cur = cur->_next;
			}

			// 头插
			Node* newnode = new Node(v);
			newnode->_next = _table[index];
			_table[index] = newnode;
			++_num;

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

		iterator Find(const K& k){
			KeyOfValue kov;
			size_t index = HashFunc(k, _table.size());
			Node* cur = _table[index];
			while (cur){
				if (kov(cur->_v) == k){
					return iterator(cur, this);
				}

				cur = cur->_next;
			}

			return end();
		}

		bool Erase(const K& k){
			KeyOfValue kov;
			size_t index = HashFunc(k, _table.size());
			Node* prev = nullptr;
			Node* cur = _table[index];

			while (cur){
				if (kov(cur->_v) == k){
					if (prev == nullptr){
						_table[index] = cur->_next;
					}
					else{
						prev->_next = cur->_next;
					}

					delete cur;
					return true;
				}

				prev = cur;
				cur = cur->_next;
			}
		}

		size_t HashFunc(const K& k, size_t n){
			HF hf;
			return hf(k) % n;
		}

	private:
		vector<Node*> _table;	//桶式结构
		size_t _num = 0;
	};
}

开散列与闭散列比较：

应用链地址法处理溢出，需要增设链接指针，似乎增加了存储开销。事实上： 由于开地址法必须保持大量的空闲空间以确保搜索效率，如二次探查法要求装载因子a <= 0.7，而表项所占空间又比指针大的多，所以使用链地址法反而比开地址法节省存储空间。

giturtle
关注
专栏目录
C++哈希结构
qq_35696023的博客
07-19 369
C++哈希结构分类 数组 set map set和map的特点如下所示 哈希结构 底层实现方式 set 红黑树 multiset 红黑树 map 红黑树 multimap 红黑树 unordered_set 哈希表 unordered_map 哈希表 底层以红黑树（平衡二叉树）实现的哈希结构的key值是有序的，查询效率都为O(logn)即平衡二叉树的深度，以哈希表实现的哈希结构的key值是无序的，查询效率为O(1)，与数组一致。注意所有的哈希结构都不可以更改key
C++ 哈希
m0_61548909的博客
08-27 2898
在 C++98 中， STL 提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 $log_2N$，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11 中， STL 又提供了 4 个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，本文中只对unordered_map 和 unordered_set 进行介绍，unordered_multimap和
【C++】常见的哈希结构
qq_44878985的博客
11-28 337
常见哈希表：数组、map、set
c++哈希
最新发布
2303_79336820的博客
09-24 993
哈希表的介绍+简单模拟实现
C++中常用的哈希结构
a1601611709的博客
03-01 370
C++中常用的哈希结构 数组 set（集合） map（映射） 以下主要谈谈set和map set 集合 底层实现 是否有序 数值是否可以重复 能否改变数值 查询效率 增删效率 set 红黑树 有序 否 否 O（logn）..
【C++】哈希结构
m0_74246469的博客
04-20 564
哈希的认识以及哈希底层结构的封装
C++:哈希结构（内含unordered_set和unordered_map实现）
JDSZGLLL的博客
03-15 471
1. unordered_map是存储键值对的关联式容器，其允许通过keys快速的索引到与 其对应的value。2. 在unordered_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此 键关联。键和映射值的类型可能不同。3. 在内部,unordered_map没有对按照任何特定的顺序排序, 为了能在常数范围内 找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。
C++哈希
qq_53413129的博客
06-09 3821
unordered系列关联式容器 unordered_map unordered_map的文档介绍 unordered_set 底层结构 哈希概念 哈希冲突的解决 闭散列： 代码实现 哈希基本结构 插入 查找find 删除 仿函数的应用 开散列 基本结构 插入的实现 查找 删除 Unordered_set/Unordered_set对哈希的封装 封装代码框架： 哈希表的迭代器 【operator*和operator->】 operator++前置++ 迭代器
C++实现哈希表。
TPON的博客
11-17 6638
C++模拟实现哈希表
哈希表de 设计.rar_c++ 哈希表_哈希_哈希 VC_哈希表
09-23
哈希表，也被称为散列表，是计算机科学中一种高效的数据结构，用于存储和检索数据。在C++中，哈希表通常通过自定义实现或使用标准库中的`unordered_map`来实现。本文将深入探讨哈希表的设计原理、工作方式以及在C++...
C++进阶：哈希结构
碧瑶的博客呀
11-13 306
哈希相关概念 哈希：用来进行高效查找的一种数据结构 首先，我们查找的方式有： （1）顺序查找，它的时间复杂度是O(n) （2）二分查找（有序），它的时间复杂度是O(log2N) （3）利用二叉平衡搜索树（AVL、红黑树）：时间复杂度是O(log2N) （4）哈希，时间复杂度是O(1) 前三种方法元素之间都要进行比较，因此时间复杂度降不下来，而哈希元素之间不需要比较（最差情况下只需少许比较即可找到）...
hash_set c++总结（自定义类型struct、class）
06-10
hash_set c++总结（自定义类型stuct、class）。总结自定义struct、class三个案例。find函数测试，hash_set迭代器。
C/C++ ＜哈希表＞数据结构
通往C/C++
09-15 450
哈希表树结构
数据结构之Hash算法
马靖的个人技术博客
05-18 2975
什么是Hash      Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数
C++常见的三种哈希结构
Solititude的博客
02-14 287
C++常见的三种哈希结构
结构体：HASH表模板
weixin_33739646的博客
03-11 106
这种 HASHMAP 就是一个链式前向星的表； 其中： init 函数：hashmap 创建初始化； check 函数：寻找 hash 表中是否有需要查找的值，若有则返回 1 ，否则返回 0 ；遍历方式与链式前向星一样； insert 函数：向 hash 表中加入新的 hash 值，若原本就有该值则返回 1 ，否则返回 0 并添加结点；添加方式与链式前向星一样； 1 #i...
双Hash模板(结构体)
Quuns的博客
07-15 655
双Hash模板(结构体)
自定义结构体的哈希函数解决337. 打家劫舍 III 
qq_40458569的博客
02-04 804
unordered_map<node,int,hashNode,cmpNode> mp; node 为key，int为value， hashNode为自定义结构体的哈希函数（unordered_map就是通过这个值去查找的） cmpNode比较函数（如果哈希值相同，怎么去处理不同的对象，也就是怎么解决冲突） /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNod
【数据结构与算法】哈希算法
dadongwudi的博客
08-19 450
一、什么是哈希算法？ 1.定义 将任意长度的二进制值串映射成固定长度的二进制值串，这个映射的规则就是哈希算法，而通过原始数据映射之后得到的二进制值串就是哈希值。 2.如何设计一个优秀的哈希算法？ ①单向哈希： 从哈希值不能反向推导出哈希值（所以哈希算法也叫单向哈希算法）。 ②篡改无效： 对输入敏感，哪怕原始数据只修改一个Bit，最后得到的哈希值也大不相同。 ③散列冲突： 散列冲突的概率要很小，对于不同的原始数据，哈希值相同的概率非常小。 ④执行效率： 哈希算法的执行效率要尽量高效，针对较长的文本，也能快速计
C++哈希表数据结构
10-05
下面是使用C++标准库中的unordered_map实现哈希表的示例代码： ``` #include int main() { // 创建一个哈希表 std::unordered_map, std::string> hashMap; // 向哈希表中插入元素 hashMap.insert({1, "apple...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

giturtle

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

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

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

打赏作者

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

抵扣说明：

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

余额充值