秒懂C++之哈希

最新推荐文章于 2026-03-30 10:18:10 发布
原创 最新推荐文章于 2026-03-30 10:18:10 发布 · 1.3k 阅读 · 27 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#哈希算法 #算法 #c++

fe594ea5bf754ddbb223a54d8fb1e7bc.gif

目录

​编辑

一. 哈希的概念

二. 哈希冲突 

三. 哈希冲突解决方法

闭散列

插入

扩容

寻找

删除

扩展

 闭散列代码

开散列 

插入

寻找

扩容

删除

扩展

开散列代码

四. 封装unordered_map/_set

底层哈希的复用

迭代器

begin/end

运算符[ ]

五. 全部代码

"MYunordered_map.h"

"MYunoredered_set.h"

"HashTable.h"

test.cpp

一. 哈希的概念

如果构造一种存储结构，通过某种函数 (hashFunc) 使元素的存储位置与它的关键码之间能够建立
一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
当向该结构中：
  • 插入元素
  • 根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
  • 搜索元素
  • 对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功
该方式即为哈希 ( 散列 ) 方法， 哈希方法中使用的转换函数称为哈希 ( 散列 ) 函数，构造出来的结构称
为哈希表 (Hash Table)( 或者称散列表 )

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

这种除留余数法虽然可以解决空间浪费的问题，但是却有不同的值映射到相同位置的风险~ 

二. 哈希冲突 

当我们再插入数据14映射时会把原本位置上的4覆盖掉，造成哈希冲突~

三. 哈希冲突解决方法

闭散列

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

插入是解决了，那么删除的问题呢？

下面的状态标记帮我们解决了问题~ 

//设置状态
enum State
{
	EMPTY,
	EXIST,
	DELETE
};

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

template<class K, class V>
class HashTable
{
public:


private:
	vector<HashDate<K,V>> _table;
};

当遇到删除的标记，查找则继续往下遍历~

插入

    HashTable(size_t size = 10)
	{
		_table.resize(size);
	}
	bool insert(const pair<K, V>& kv)
	{
		//控制在载荷因子允许范围内
		if ((n * 10 / _table.size()) >= 7)
		{
			//开始扩容
			size_t newsize = _table.size() * 2;

		}
		//要映射的下标位置
		size_t hashi = kv.first % _table.size();
		//判断当前映射的下标位置的状态
		while(_table[hashi]->_state == EXIST)
		{
			hashi++;
			//到尾部时能够返回到头部
			hashi%= _table.size();
		}
		//当前映射下标可以插入
		_table[hashi]._data = kv;
		_table[hashi]._state = EXIST;
		n++;
	}

ps:这里取模我们只能用size而不能用capacity

如果用capacity取模会插入在size之外的下标，而vector的[ ]特性中对会>size的越界访问进行报错，所以我们只好把size近似当作capacity来处理了(初始化别给0即可）~

下面我们再从插入的基础上思考扩容问题~

扩容

    bool insert(const pair<K, V>& kv)
	{
        //如果已存在，无法插入
		if (Find(kv.first))
		{
			return false;
		}
		//控制在载荷因子允许范围内
		if ((n * 10 / _table.size()) >= 7)
		{
			//开始扩容
			size_t newsize = _table.size() * 2;
			vector<HashDate> _newtable(newsize);
			//遍历旧表，插入新表
			//..........
			_table.swap(_newtable);
		}
		//要映射的下标位置
		size_t hashi = kv.first % _table.size();
		//判断当前映射的下标位置的状态
		while(_table[hashi]->_state == EXIST)
		{
			hashi++;
			//到尾部时能够返回到头部
			hashi%= _table.size();
		}
		//当前映射下标可以插入
		_table[hashi]._data = kv;
		_table[hashi]._state = EXIST;
		n++;
	}

这种扩容方式的麻烦之处就在于遍历旧表插入新表时还得按下面插入的内容再走一次~

bool insert(const pair<K, V>& kv)
	{
        //如果已存在，无法插入
		if (Find(kv.first))
		{
			return false;
		}
		//控制在载荷因子允许范围内
		if ((n * 10 / _table.size()) >= 7)
		{
			//开始扩容
			HashTable<K, V> newHT(_table.size() * 2);
			//遍历旧表，插入新表
			for (auto& e : _table)
			{
				//复用
				newHT.insert(e._data);
			}
			_table.swap(newHT._table);
		}
		//要映射的下标位置
		size_t hashi = kv.first % _table.size();
		//判断当前映射的下标位置的状态
		while(_table[hashi]._state == EXIST)
		{
			hashi++;
			//到尾部时能够返回到头部
			hashi%= _table.size();
		}
		//当前映射下标可以插入
		_table[hashi]._data = kv;
		_table[hashi]._state = EXIST;
		n++;
	}

这里我们重新生成一个对象，然后设置该对象内_table的size为旧表的两倍，这样遍历旧表插入新表的时候就可以用成员函数insert进行复用，最后再交换数据即可~

第一种方式只是在一个对象内生成另一个vector，然后对象内部进行交换。而第二种是有两个对象，跨对象的数据进行交换~区别在于后者可以使用其成员函数，减少代码冗余~

寻找

    HashDate<K, V>* Find(const K& key)
	{
		//要映射的下标位置
		size_t hashi = key % _table.size();
		//判断当前映射的下标位置的状态
		while (_table[hashi]._state != EMPTY)
		{
			if (_table[hashi]._data.first == key && _table[hashi]._state == EXIT)
			{
				return &_table[hashi];
			}
			hashi++;
			//到尾部时能够返回到头部
			hashi %= _table.size();
		}
		return nullptr;
	}

由于我们还没有模拟实现迭代器，这里我们利用Find函数来帮助我们测试插入效果~

删除

bool erase(const K& key)
	{
		//利用find快速查找
		HashDate<K, V>* ret = Find(key);
		if (ret)
		{
			ret->_state = DELETE;
			n--;
			return true;
		}
		else
		{
			return false;
		}
	}

扩展

通常我们是利用整型key取模来映射下标位置，那如果我们的key值变成string或自定义类（日期类）的时候我们是无法把它们强制转化为整型去取模的，这时候应该如何去做呢？

我们可以给哈希表再加上一层映射，通过映射让可以强转为整型的key值转化为可以被取模的整型，让无法被强转为整型的key值进行特殊处理~

那么关于字符串我们应该采用哪种方式进行最终的取模呢？

一般是让各个字符的ascll码值相加，这样就可以确保每个字符串的唯一性的同时还可以转化为整型进行取模映射下标位置~

//不可强转
struct HashString
{
	size_t operator()(const string& s)
	{
		size_t hash = 0;
		for (auto e : s)
		{
			hash += e;
			//*5是为了避免“abcd","acbd"这种例子的发生
			hash *= 5;
		}
		return hash;
	}
};

不过对于string这种采用的key值，我们一般用另一种方式进行转化~

// 特化
template<>
struct HashFunc<string>
{
	size_t operator()(const string& s)
	{
		size_t hash = 0;
		for (auto e : s)
		{
			hash += e;
			hash *= 5;
		}

		return hash;
	}
};

可以利用特化的方式进行更准确的参数匹配~

 闭散列代码

#pragma once

namespace close
{

//设置状态
enum State
{
	EMPTY,
	EXIST,
	DELETE
};

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

template<class K>
//可强转
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

// 特化
template<>
struct HashFunc<string>
{
	size_t operator()(const string& s)
	{
		size_t hash = 0;
		for (auto e : s)
		{
			hash += e;
			hash *= 5;
		}

		return hash;
	}
};

//
////不可强转
//struct HashString
//{
//	size_t operator()(const string& s)
//	{
//		size_t hash = 0;
//		for (auto e : s)
//		{
//			hash += e;
//			//*5是为了避免“abcd","acbd"这种例子的发生
//			hash *= 5;
//		}
//		return hash;
//	}
//};

template<class K, class V,class Hash = HashFunc<K>>
class HashTable
{
public:
	HashTable(size_t size = 10)
	{
		_table.resize(size);
	}

	bool erase(const K& key)
	{
		//利用find快速查找
		HashDate<K, V>* ret = Find(key);
		if (ret)
		{
			ret->_state = DELETE;
			n--;
			return true;
		}
		else
		{
			return false;
		}
	}

	HashDate<K, V>* Find(const K& key)
	{
		Hash hs;
		// 线性探测
		size_t hashi = hs(key) % _table.size();
		//判断当前映射的下标位置的状态
		while (_table[hashi]._state != EMPTY)
		{
			if (_table[hashi]._data.first == key && _table[hashi]._state == EXIST)
			{
				return &_table[hashi];
			}
			hashi++;
			//到尾部时能够返回到头部
			hashi %= _table.size();
		}
		return nullptr;
	}


	bool insert(const pair<K, V>& kv)
	{
		//如果已存在，无法插入
		if (Find(kv.first))
		{
			return false;
		}
		//控制在载荷因子允许范围内
		if ((n * 10 / _table.size()) >= 7)
		{
			////开始扩容
			//size_t newsize = _table.size() * 2;
			//vector<HashDate> _newtable(newsize);
			////遍历旧表，插入新表
			////..........
			//_table.swap(_newtable);
			// 
			//开始扩容
			HashTable<K, V,Hash> newHT(_table.size() * 2);
			//遍历旧表，插入新表
			for (auto& e : _table)
			{
				//复用
				newHT.insert(e._data);
			}
			_table.swap(newHT._table);
		}
		Hash hs;
		//要映射的下标位置
		size_t hashi = hs(kv.first) % _table.size();
		//判断当前映射的下标位置的状态
		while(_table[hashi]._state == EXIST)
		{
			hashi++;
			//到尾部时能够返回到头部
			hashi%= _table.size();
		}
		//当前映射下标可以插入
		_table[hashi]._data = kv;
		_table[hashi]._state = EXIST;
		n++;
	}

private:
	vector<HashDate<K,V>> _table;
	//有效个数
	size_t n;

};
void test1()
{
	int a[] = { 1,4,24,34,7,44,17,37 };
	HashTable<int, int> ht;
	for (auto e : a)
	{
		ht.insert(make_pair(e, e));
	}
	ht.erase(1);
	ht.erase(34);

	for (auto e : a)
	{
		auto ret = ht.Find(e);
		if (ret)
		{
			cout << ret->_data.first << ":E" << endl;
		}
		else
		{
			cout << e<< ":D" << endl;
		}
	}
	cout << endl;

}
void test2()
{
	HashTable<string, string> dict;
	dict.insert(make_pair("sort", "排序"));
	dict.insert(make_pair("string", "字符串"));

}
}

开散列 

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

namespace open
{
	template<class K, class V>
	struct HashNode
	{
		pair<K, V> _kv;
		HashNode<K, V>* _next;
        HashNode(const pair<K, V>& kv)
			:_next(nullptr)
			,_kv(kv)
		{}
	};
	template<class K,class V>
	class HashTable
	{
	public:

	private:
		//直接套用list
		//vector<list<pair<K, V>>> _table;
		//自己写一个,指针数组
		vector<HashNode<K,V>*> _table;
        size_t n;

	};
}

这里我们不直接用容器list的原因是方便自己写一个迭代器

插入

    bool insert(const pair<K,V>& kv)
		{
			size_t hashi = kv.first % _table.size();
			Node* newnode = new Node(kv);
			//头插
			newnode->_next = _table[hashi];
			_table[hashi] = newnode;
            n++;
			return true;
		}

寻找

        //寻找          
		//我们需要查到的是值，而这些值在节点中
		Node* Find(const K& key)
		{
			//映射下标
			size_t hashi = key % _table.size();
			Node* cur = _table[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}
				cur = cur->_next;
			}
			return nullptr;
		}

扩容

//插入
		bool insert(const pair<K,V>& kv)
		{
			if (Find(kv.first))
			{
				return false;	
			}
			//负载因子为1
			//扩容
			if (n == _table.size())
			{
				vector<Node*> _newtable(_table.size()*2,nullptr);
				for (size_t i = 0; i < _table.size(); i++)
				{
					//遍历每一个桶
					Node* cur = _table[i];
					//把桶里的节点都移动到新表中
					while (cur)
					{
						//保存好下一节点
						Node* next = cur->_next;
						//映射当前节点在新表中的位置
						size_t hashi = cur->_kv.first % _newtable.size();
						//头插
						cur->_next = _newtable[hashi];
						_newtable[hashi] = cur;
						//对该桶下一节点进行转移
						cur = next;
					}
					//节点全部转移完毕，清空旧表指针指向
					_table[i] = nullptr;
				}
				//两表交换完成扩容
				_table.swap(_newtable);
			}
			size_t hashi = kv.first % _table.size();
			Node* newnode = new Node(kv);
			//头插
			newnode->_next = _table[hashi];
			_table[hashi] = newnode;
			n++;
			return true;

		}

这一次的扩容与线性探测不太一样，之前我们为了方便插入到新表选择重新构成一个类对象来复用Insert,而这一次是为了避免节点的浪费转而采用移动节点的方式进行插入新表~

删除

//删除
		bool erase(const K& key)
		{
			//找到要删除的映射位置(桶）
			size_t hashi = key % _table.size();
			//遍历当前桶节点
			Node* cur = _table[hashi];
			//保留前一个节点，使其删除后链接
			Node* prev = nullptr;
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					//若非头删
					if (prev)
					{
						prev->_next = cur->_next;
					}
					//若恰好头删
					else
					{
						_table[hashi] = cur->_next;
					}
					//节点删除
					delete cur;
					n--;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}
			return false;
		}

删除我们得考虑在这之后节点之间的链接~

扩展

最后我们再来写一下关于字符串取模的类模板~

    //可强转
	template<class K>
	struct HashFunc
	{
		size_t operator()(const K& key)
		{
			return (size_t)key;
		}
	};

	// 特化
	template<>
	struct HashFunc<string>
	{
		size_t operator()(const string& s)
		{
			size_t hash = 0;
			for (auto e : s)
			{
				hash += e;
				hash *= 5;
			}

			return hash;
		}
	};
	template<class K,class V,class Hash = HashFunc<K>>
	class HashTable...

开散列代码

namespace open
{
	template<class K, class V>
	struct HashNode
	{
		pair<K, V> _kv;
		HashNode<K, V>* _next;
		HashNode(const pair<K, V>& kv)
			:_next(nullptr)
			, _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& s)
		{
			size_t hash = 0;
			for (auto e : s)
			{
				hash += e;
				hash *= 5;
			}

			return hash;
		}
	};
	template<class K,class V,class Hash = HashFunc<K>>
	class HashTable
	{
		typedef HashNode<K, V> Node;
	public:
		HashTable()
		{
			_table.resize(10, nullptr);
			n = 0;
		}

		~HashTable()
		{
			for (size_t i = 0; i < _table.size(); i++)
			{
				Node* cur = _table[i];
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;

					cur = next;
				}
				_table[i] = nullptr;
			}
		}

		//删除
		bool erase(const K& key)
		{
			Hash hh;
			//找到要删除的映射位置(桶）
			size_t hashi = hh(key) % _table.size();
			//遍历当前桶节点
			Node* cur = _table[hashi];
			//保留前一个节点，使其删除后链接
			Node* prev = nullptr;
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					//若非头删
					if (prev)
					{
						prev->_next = cur->_next;
					}
					//若恰好头删
					else
					{
						_table[hashi] = cur->_next;
					}
					//节点删除
					delete cur;
					n--;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}
			return false;
		}


		//寻找          
		//我们需要查到的是值，而这些值在节点中
		Node* Find(const K& key)
		{
			Hash hh;
			//映射下标
			size_t hashi = hh(key) % _table.size();
			Node* cur = _table[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}
				cur = cur->_next;
			}
			return nullptr;
		}

		

		//插入
		bool insert(const pair<K,V>& kv)
		{
			Hash hh;
			if (Find(kv.first))
			{
				return false;	
			}
			//负载因子为1
			//扩容
			if (n == _table.size())
			{
				vector<Node*> _newtable(_table.size()*2,nullptr);
				for (size_t i = 0; i < _table.size(); i++)
				{
					//遍历每一个桶
					Node* cur = _table[i];
					//把桶里的节点都移动到新表中
					while (cur)
					{
						//保存好下一节点
						Node* next = cur->_next;
						//映射当前节点在新表中的位置
						size_t hashi = hh(cur->_kv.first) % _newtable.size();
						//头插
						cur->_next = _newtable[hashi];
						_newtable[hashi] = cur;
						//对该桶下一节点进行转移
						cur = next;
					}
					//节点全部转移完毕，清空旧表指针指向
					_table[i] = nullptr;
				}
				//两表交换完成扩容
				_table.swap(_newtable);
			}
			size_t hashi = hh(kv.first) % _table.size();
			Node* newnode = new Node(kv);
			//头插
			newnode->_next = _table[hashi];
			_table[hashi] = newnode;
			n++;
			return true;
		}
	private:
		//直接套用list
		//vector<list<pair<K, V>>> _table;
		//自己写一个,指针数组
		vector<Node*> _table;
		size_t n;
	};
	void Test1()
	{
		//HashTable<int, int> ht;
		//int a[] = { 1,4,24,34,7,44,17,37 };
		//for (auto e : a)
		//{
		//	ht.insert(make_pair(e, e));
		//}
		///*ht.insert(make_pair(5, 5));
		//ht.insert(make_pair(15, 15));
		//ht.insert(make_pair(25, 25));*/
		//ht.erase(1);
		//ht.erase(4);
		//ht.erase(24);
		//ht.erase(34);

		HashTable<string, string> dict;
		dict.insert(make_pair("sort", "排序"));
		dict.insert(make_pair("string", "字符串"));
	}
}

四. 封装unordered_map/_set

我们已经把unordered_map/_set底层的哈希层构建好了，接下来就是根据二者其特点用哈希进行封装~

底层哈希的复用

#pragma once
#include "HashTable.h"

namespace lj
{
	template<class K, class Hash = open::HashFunc<K>>
	class unordered_set
	{
		struct setkey
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	private:
		//调用底层哈希
		open::HashTable<K, K, setkey,Hash> _ht;
	};
}
#pragma once
#include "HashTable.h"

namespace lj
{
	template<class K, class V, class Hash = open::HashFunc<K>>
	class unordered_map
	{
		struct mapkey
		{
			const K& operator()(const pair<K,V>& kv)
			{
				return kv.first;
			}
		};
	private:
		//调用底层哈希
		open::HashTable<K, pair<K,V>, mapkey,Hash> _ht;
	};
}

迭代器

//迭代器
	template <class K,class T,class whokey,class Hash>
	struct _HTIterator
	{
		typedef HashNode<T> Node;
		typedef HashTable<K, T, whokey, Hash> HT;
		typedef _HTIterator<K, T, whokey, Hash> Self;
		Node* _node;
		HT* _ht;

		_HTIterator(Node*_node,HT*_ht)
			:_node
			,ht(_ht)
		{}
		T& operator*()
		{
			return _node->_data;
		}

		Self& operator++()
		{
			whokey wk;
			Hash hh;
			//若当前桶还没走完
			if (_node->_next)
			{
				//继续走当前桶内节点
				_node = _node->_next;
			}
			//若当前桶已走完，则前往下一个桶
			else
			{
				//映射当前位置
				size_t hashi = hh(wk(_node->_data)) % _ht->_table.size();
				hashi++;
				while (hashi < _ht->_table.size())
				{
					//若当前桶内有节点
					if (_ht->_table[hashi])
					{
                        _node = _ht->_table[hashi];
						//找到下一个桶的位置
						break;
					}
					else
					{
						hashi++;
					}
				}
				//如果到最后都找不到下一个桶
				if (hashi == _ht->_table.size())
				{
					//那么下一个即为空
					return nullptr;
				}
			}
			return *this;
		}


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


	};

begin/end

        iterator begin()
		{
			//找到第一个桶的第一个节点
			for (size_t i = 0; i < _table.size(); i++)
			{
				if (_table[i])
				{
					return iterator(_table[i], this);
				}
			}
			return end();
		}
		
		iterator end()
		{
			return iterator(nullptr, this);
		}

运算符[ ]

        pair<iterator,bool> insert(const pair<K, V>& kv)
		{
			return _ht.insert(kv);
		}

		

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

 

        pair<iterator,bool> insert(const T& data)
		{
			whokey wk;
			Hash hh;
			iterator it = Find(wk(data));
			if (it != end())
			{
				return make_pair(it, false);
			}
			/*if (Find(wk(data))!=end())
			{
				return false;	
			}*/
			//负载因子为1
			//扩容
			if (n == _table.size())
			{
				vector<Node*> _newtable(_table.size()*2,nullptr);
				for (size_t i = 0; i < _table.size(); i++)
				{
					//遍历每一个桶
					Node* cur = _table[i];
					//把桶里的节点都移动到新表中
					while (cur)
					{
						//保存好下一节点
						Node* next = cur->_next;
						//映射当前节点在新表中的位置
						size_t hashi = hh(wk(cur->_data)) % _newtable.size();
						//头插
						cur->_next = _newtable[hashi];
						_newtable[hashi] = cur;
						//对该桶下一节点进行转移
						cur = next;
					}
					//节点全部转移完毕，清空旧表指针指向
					_table[i] = nullptr;
				}
				//两表交换完成扩容
				_table.swap(_newtable);
			}
			size_t hashi = hh(wk(data)) % _table.size();
			Node* newnode = new Node(data);
			//头插
			newnode->_next = _table[hashi];
			_table[hashi] = newnode;
			n++;
			return make_pair(iterator(newnode, this), true);
			//return true;
		}

 

五. 全部代码

"MYunordered_map.h"

#pragma once
#include "HashTable.h"

namespace lj
{
	template<class K, class V, class Hash = open::HashFunc<K>>
	class unordered_map
	{
		struct mapkey
		{
			const K& operator()(const pair<K,V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename open::HashTable<K, pair<const K, V>, mapkey, Hash>::iterator iterator;

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

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

		pair<iterator,bool> insert(const pair<K, V>& kv)
		{
			return _ht.insert(kv);
		}

		iterator find(const K& key)
		{
			return _ht.Find(key);
		}

		bool erase(const K& key)
		{
			return _ht.erase(key);
		}

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

	private:
		//调用底层哈希
		open::HashTable<K, pair<const K,V>, mapkey,Hash> _ht;
	};
	void test_map1()
	{
		unordered_map<string, string> dict;
		dict.insert(make_pair("apple", "苹果"));
		dict.insert(make_pair("left", "左边"));
		dict.insert(make_pair("right", "右边"));

		for (auto& kv : dict)
		{

			cout << kv.first << ":" << kv.second << endl;
		}
	}
	void test_map2()
	{
		string arr[] = { "ppp","ddd","aaa","aaa" ,"aaa" ,"aaa" ,"ddd" };
		unordered_map<string, int> conutmap;
		for (auto& e : arr)
		{
			conutmap[e]++;
		}

		for (auto& kv : conutmap)
		{

			cout << kv.first << ":" << kv.second << endl;
		}
	}
}

"MYunoredered_set.h"

#pragma once
#include "HashTable.h"

namespace lj
{
	template<class K, class Hash = open::HashFunc<K>>
	class unordered_set
	{
		struct setkey
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename open::HashTable<K, const K, setkey, Hash>::iterator iterator;

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

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

		pair<iterator, bool> Insert(const K& key)
		{
			return _ht.insert(key);
		}

		iterator find(const K& key)
		{
			return _ht.Find(key);
		}

		bool erase(const K& key)
		{
			return _ht.erase(key);
		}


	private:
		//调用底层哈希
		open::HashTable<K, const K, setkey,Hash> _ht;
	};
	void test_set1()
	{
		unordered_set<int> us;
		us.Insert(3);
		us.Insert(1);
		us.Insert(5);
		us.Insert(15);
		us.Insert(45);
		us.Insert(7);

		unordered_set<int>::iterator it = us.begin();
		while (it != us.end())
		{
			//*it += 100;
			cout << *it << " ";
			++it;
		}
		cout << endl;

		if (us.find(1) != us.end())
		{
			cout << "找到了" << endl;
		}
		for (auto e : us)
		{
			cout << e << " ";
		}
		cout << endl;
	}
}

"HashTable.h"

#pragma once

namespace close
{

//设置状态
enum State
{
	EMPTY,
	EXIST,
	DELETE
};

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

template<class K>
//可强转
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

// 特化
template<>
struct HashFunc<string>
{
	size_t operator()(const string& s)
	{
		size_t hash = 0;
		for (auto e : s)
		{
			hash += e;
			hash *= 5;
		}

		return hash;
	}
};

//
////不可强转
//struct HashString
//{
//	size_t operator()(const string& s)
//	{
//		size_t hash = 0;
//		for (auto e : s)
//		{
//			hash += e;
//			//*5是为了避免“abcd","acbd"这种例子的发生
//			hash *= 5;
//		}
//		return hash;
//	}
//};

template<class K, class V,class Hash = HashFunc<K>>
class HashTable
{
public:
	HashTable(size_t size = 10)
	{
		_table.resize(size);
	}

	bool erase(const K& key)
	{
		//利用find快速查找
		HashDate<K, V>* ret = Find(key);
		if (ret)
		{
			ret->_state = DELETE;
			n--;
			return true;
		}
		else
		{
			return false;
		}
	}

	HashDate<K, V>* Find(const K& key)
	{
		Hash hs;
		// 线性探测
		size_t hashi = hs(key) % _table.size();
		//判断当前映射的下标位置的状态
		while (_table[hashi]._state != EMPTY)
		{
			if (_table[hashi]._data.first == key && _table[hashi]._state == EXIST)
			{
				return &_table[hashi];
			}
			hashi++;
			//到尾部时能够返回到头部
			hashi %= _table.size();
		}
		return nullptr;
	}


	bool insert(const pair<K, V>& kv)
	{
		//如果已存在，无法插入
		if (Find(kv.first))
		{
			return false;
		}
		//控制在载荷因子允许范围内
		if ((n * 10 / _table.size()) >= 7)
		{
			////开始扩容
			//size_t newsize = _table.size() * 2;
			//vector<HashDate> _newtable(newsize);
			////遍历旧表，插入新表
			////..........
			//_table.swap(_newtable);
			// 
			//开始扩容
			HashTable<K, V,Hash> newHT(_table.size() * 2);
			//遍历旧表，插入新表
			for (auto& e : _table)
			{
				//复用
				newHT.insert(e._data);
			}
			_table.swap(newHT._table);
		}
		Hash hs;
		//要映射的下标位置
		size_t hashi = hs(kv.first) % _table.size();
		//判断当前映射的下标位置的状态
		while(_table[hashi]._state == EXIST)
		{
			hashi++;
			//到尾部时能够返回到头部
			hashi%= _table.size();
		}
		//当前映射下标可以插入
		_table[hashi]._data = kv;
		_table[hashi]._state = EXIST;
		n++;
	}

private:
	vector<HashDate<K,V>> _table;
	//有效个数
	size_t n;

};
void test1()
{
	int a[] = { 1,4,24,34,7,44,17,37 };
	HashTable<int, int> ht;
	for (auto e : a)
	{
		ht.insert(make_pair(e, e));
	}
	ht.erase(1);
	ht.erase(34);

	for (auto e : a)
	{
		auto ret = ht.Find(e);
		if (ret)
		{
			cout << ret->_data.first << ":E" << endl;
		}
		else
		{
			cout << e<< ":D" << endl;
		}
	}
	cout << endl;

}
void test2()
{
	HashTable<string, string> dict;
	dict.insert(make_pair("sort", "排序"));
	dict.insert(make_pair("string", "字符串"));

}
}

namespace open
{
	//可强转
	template<class K>
	struct HashFunc
	{
		size_t operator()(const K& key)
		{
			return (size_t)key;
		}
	};

	// 特化
	template<>
	struct HashFunc<string>
	{
		size_t operator()(const string& s)
		{
			size_t hash = 0;
			for (auto e : s)
			{
				hash += e;
				hash *= 5;
			}

			return hash;
		}
	};
	// T -> K
	// T -> pair<K, V>
	template<class T>		
	struct HashNode
	{
		HashNode<T>* _next;
		T _data;
		HashNode(const T& data)
			:_next(nullptr)
			, _data(data)
		{}
	};
	// 前置声明
	template<class K, class T, class whokey, class Hash>
	class HashTable;

	//迭代器
	template <class K,class T,class whokey,class Hash>
	struct _HTIterator
	{
		typedef HashNode<T> Node;
		typedef HashTable<K, T, whokey, Hash> HT;
		typedef _HTIterator<K, T, whokey, Hash> Self;
		Node* _node;//指向节点
		HT* _ht;//指向桶

		_HTIterator(Node* node, HT* ht)
			:_node(node)
			, _ht(ht)
		{}

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

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

		Self& operator++()
		{
			
			//若当前桶还没走完
			if (_node->_next)
			{
				//继续走当前桶内节点
				_node = _node->_next;
			}
			//若当前桶已走完，则前往下一个桶
			else
			{
				whokey wk;
				Hash hh;
				//映射当前位置
				size_t hashi = hh(wk(_node->_data)) % _ht->_table.size();
				hashi++;
				while (hashi < _ht->_table.size())
				{
					//若当前桶内有节点
					if (_ht->_table[hashi])
					{
						_node = _ht->_table[hashi];
						//找到下一个桶的位置
						break;
					}
					else
					{
						hashi++;
					}
				}
				//如果到最后都找不到下一个桶
				if (hashi == _ht->_table.size())
				{
					//那么下一个即为空
					_node = nullptr;
				}
			}
			return *this;
		}

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


	};
	
	
	template<class K,class T,class whokey,class Hash>
	class HashTable
	{
		//前置声明
		template<class K, class T, class whokey, class Hash>
		friend struct _HTIterator;//友元类
		typedef HashNode<T> Node;
	public:
		typedef _HTIterator<K, T, whokey, Hash> iterator;

		iterator begin()
		{
			//找到第一个桶的第一个节点
			for (size_t i = 0; i < _table.size(); i++)
			{
				if (_table[i])
				{
					return iterator(_table[i], this);
				}
			}
			return end();
		}
		
		iterator end()
		{
			return iterator(nullptr, this);
		}

		HashTable()
		{
			_table.resize(10, nullptr);
			n = 0;
		}

		~HashTable()
		{
			for (size_t i = 0; i < _table.size(); i++)
			{
				Node* cur = _table[i];
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;

					cur = next;
				}
				_table[i] = nullptr;
			}
		}

		//删除
		bool erase(const K& key)
		{
			whokey wk;
			Hash hh;
			//找到要删除的映射位置(桶）
			size_t hashi = hh(key) % _table.size();
			//遍历当前桶节点
			Node* cur = _table[hashi];
			//保留前一个节点，使其删除后链接
			Node* prev = nullptr;
			while (cur)
			{
				if (wk(cur->_data) == key)
				{
					//若非头删
					if (prev)
					{
						prev->_next = cur->_next;
					}
					//若恰好头删
					else
					{
						_table[hashi] = cur->_next;
					}
					//节点删除
					delete cur;
					n--;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}
			return false;
		}


		//寻找          
		//我们需要查到的是值，而这些值在节点中
		iterator Find(const K& key)
		{
			whokey wk;
			Hash hh;
			//映射下标
			size_t hashi = hh(key) % _table.size();
			Node* cur = _table[hashi];
			while (cur)
			{
				if (wk(cur->_data) == key)
				{
					return iterator(cur,this);
				}
				cur = cur->_next;
			}
			return iterator(nullptr,this);
		}

		

		//插入
		pair<iterator,bool> insert(const T& data)
		{
			whokey wk;
			Hash hh;
			iterator it = Find(wk(data));
			if (it != end())
			{
				return make_pair(it, false);
			}
			/*if (Find(wk(data))!=end())
			{
				return false;	
			}*/
			//负载因子为1
			//扩容
			if (n == _table.size())
			{
				vector<Node*> _newtable(_table.size()*2,nullptr);
				for (size_t i = 0; i < _table.size(); i++)
				{
					//遍历每一个桶
					Node* cur = _table[i];
					//把桶里的节点都移动到新表中
					while (cur)
					{
						//保存好下一节点
						Node* next = cur->_next;
						//映射当前节点在新表中的位置
						size_t hashi = hh(wk(cur->_data)) % _newtable.size();
						//头插
						cur->_next = _newtable[hashi];
						_newtable[hashi] = cur;
						//对该桶下一节点进行转移
						cur = next;
					}
					//节点全部转移完毕，清空旧表指针指向
					_table[i] = nullptr;
				}
				//两表交换完成扩容
				_table.swap(_newtable);
			}
			size_t hashi = hh(wk(data)) % _table.size();
			Node* newnode = new Node(data);
			//头插
			newnode->_next = _table[hashi];
			_table[hashi] = newnode;
			n++;
			return make_pair(iterator(newnode, this), true);
			//return true;
		}
	private:
		//直接套用list
		//vector<list<pair<K, V>>> _table;
		//自己写一个,指针数组
		vector<Node*> _table;
		size_t n;
	};
	//void Test1()
	//{
	//	//HashTable<int, int> ht;
	//	//int a[] = { 1,4,24,34,7,44,17,37 };
	//	//for (auto e : a)
	//	//{
	//	//	ht.insert(make_pair(e, e));
	//	//}
	//	///*ht.insert(make_pair(5, 5));
	//	//ht.insert(make_pair(15, 15));
	//	//ht.insert(make_pair(25, 25));*/
	//	//ht.erase(1);
	//	//ht.erase(4);
	//	//ht.erase(24);
	//	//ht.erase(34);

	//	/*HashTable<string, string> dict;
	//	dict.insert(make_pair("sort", "排序"));
	//	dict.insert(make_pair("string", "字符串"));*/
	//}
}

test.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include <vector>
#include <iostream>
#include<unordered_map>
#include<unordered_set>
#include<set>
#include<map>
using namespace std;


#include "HashTable.h"
#include "MYunordered_map.h"
#include "MYunoredered_set.h"
int main()
{
	//test1();
	//close::test2();
	//open::Test1();
	//lj::test_map1();
	//lj::test_set1();
	lj::test_map2();
	return 0;
}

【C++】哈希
须知少日拏云志，曾许人间第一流。
04-15 2560
讲解哈希结构、哈希碰撞、开散列和闭散列及其模拟实现。
一篇文章搞懂C++实现哈希算法
weixin_73570479的博客
05-13 4824
哈希算法，也称为散列算法，是一种从任意长度的输入数据创建固定大小输出的方法，这种输出通常被称为“哈希值”、“散列值”或简单地“哈希”。在计算机科学中，哈希算法主要用于快速数据查找和数据结构中的高效数据管理，如哈希表。哈希也是加密和数据完整性验证的基础。哈希算法通过一个称为哈希函数的数学过程来运作。这个函数接受输入（称为“预映射值”）并返回一个通常较短、固定长度的哈希值。这个哈希值在理想情况下为每个不同的输入值提供一个唯一的标识（尽管在实际中这并不总是可能的）。
C++——哈希
2302_80007250的博客
09-08 1635
undered_map是存储键值对<key,value>的关联式容器。与map不同，undered_map存储的key没有顺序，但同样是通过key索引得到value。undered_map中的键值key不可修改且唯一。undered_map支持[ ]访问，下标为键值key。如果key不存在，那么会将key进行插入，对应的value为默认值。undered_map的通过key访问value的效率比map快函数声明功能介绍构造不同格式的undered_map对象。
C++ —— 哈希
最新发布
2302_80045891的博客
03-30 361
多个值就算key不等，但是通过取模之类的导致映射到相同的位置去了，冲突了，通过线性探测的方式存起来了，不是我要找的值，还要进行探测，所以确认我要找的值，就要比较key相等。指针也是不能取模的，指针是地址的编号，强转之后就成整数了，就能取模了。开放定址法中所有的元素都放到哈希表⾥，链地址法中所有的数据不再直接存储在哈希表中，哈希表中存储⼀个指针，没有数据映射这个位置时，这个指针为空，有多个数据映射到这个位置时，我们把这些冲突的数据链接成⼀个链表，挂在哈希表这个位置下⾯，链地址法也叫做拉链法或者哈希桶。
C++哈希算法详解(hash、hash!)
2401_90042730的博客
03-06 1922
C++哈希算法详解
[C++] 哈希详解
weixin_43717520的博客
08-29 9267
哈希
秒懂C++之哈希的应用
fax_player的博客
09-03 1237
增加和查询元素的时间复杂度为:O(K), (K为哈希函数的个数，一般比较小，与数据量大小无关哈希函数相互之间没有关系，方便硬件并行运算布隆过滤器不需要存储元素本身，在某些对保密要求比较严格的场合有很大优势在能够承受一定的误判时，布隆过滤器比其他数据结构有这很大的空间优势数据量很大时，布隆过滤器可以表示全集，其他数据结构不能使用同一组散列函数的布隆过滤器可以进行交、并、差运算。
C++ 哈希表详解：简单通俗秒懂
2201_75395601的博客
10-18 524
哈希表（Hash Table）是程序设计中最神奇也最常用的数据结构之一，它能让我们在 O(1) 的时间内找到想要的数据。本文将用生活化的比喻和完整的 C++ 示例，带你彻底理解哈希表的原理。
哈希算法：完整讲解与实现
热门推荐
Interview_TC的博客
12-11 1万+
哈希算法（Hash Algorithm）是一种映射函数，将任意长度的输入数据映射为固定长度的输出数据。这个输出称为哈希值（Hash Value）或消息摘要特点：将输入映射为固定的 128 位哈希值。快速，但安全性较低。用途：文件完整性校验。SHA-1：生成 160 位哈希值，比 MD5 更安全，但已被淘汰。SHA-256：更安全的算法，生成 256 位哈希值，广泛用于密码学。特点：快速计算，生成 32 位校验值，主要用于数据传输。用途：网络协议中的数据完整性验证。
【C++】 哈希
qq_62939852的博客
05-20 3165
需要使用枚举来表示三种状态 删除 存在 空表示状态的state 也应该默认设为空，不然有可能造成 映射位置 没有数据但是 状态为存在的情况。
C++进阶 —— 哈希
NapoleonCoder的博客
12-12 3670
哈希表！
C++ 哈希详解
yn_zi的博客
06-28 2510
具体来说，当使用直接定址法时，我们可以通过一个固定的偏移量或者一个简单的数学运算来计算输入值对应的哈希表位置。然而，拉链法也存在一些缺点。在使用拉链法时，通过哈希函数计算键的哈希值，并访问对应的槽。总之，拉链法是一种解决哈希冲突的方法，通过在哈希表的每个槽中存储一个链表来保存具有相同哈希值的键值对。无论是哪种探测方法，在哈希表逐渐接近满的过程中，插入数据的效率会越来越低，因此闭散列哈希表不能满了再增容。进行同样的计算，把求得的函数值当做元素的存储位置，在节后中按此位置取元素比较，若关键码相等，则搜索成功。
【C++】---哈希算法
weixin_75128035的博客
08-27 2112
简单的说，就是运用->哈希思想，而形成的数据结构！就是找出各个数据对应的储存位置的转换公式！按照这种方法查找不用拿key多次比较，不用像链表2叉树等等那些数据结构进行多次比较才会查找到结果。因此查找的速度比较快。哈希冲突：就是说，不同的数据，通过哈希函数，来计算出它所对应的映射位置的时候，位置相同，就是哈希冲突！比如说这里的10001和11，%10之后，他们所得的值都是1，都应该放在下标为1的位置，这就是哈希冲突！引起哈希冲突的原因：哈希函数设计不合理。
【C++】-- 哈希算法
局部变量和全局变量
09-20 6257
如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的key之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。 向该结构中插入元素和查找元素时： 插入元素：将元素key存放到用hashFunc计算出的元素key的位置。 查找元素：对元素的key进行计算，把用hashFunc计算的函数值当做元素的存储位置，在哈希结构中按此位置取元素比较，若key相等，则查找成功。
C++进阶：哈希
QinMou
10-21 1104
哈希(hash)⼜称散列，是⼀种组织数据的⽅式。从译名来看，有散乱排列的意思。本质就是通过哈希函数把关键字Key跟存储位置建⽴⼀个映射关系，查找时通过这个哈希函数计算出Key存储的位置，进⾏快速查找。
哈希表的实现--C++
小志的博客
11-13 5262
当key是string/Date等类型时，key不能取模，那么我们需要给HashTable增加一个仿函数，这个仿函数⽀持把key转换成一个可以取模的整形，如果key可以转换为整形并且不容易冲突，那么这个仿函数就用默认参数即可，如果这个Key不能转换为整形，我们就需要自己实现一个仿函数传给这个参数，实现这个仿函数的要求就是尽量key的每值都参与到计算中，让不同的key转换出的整形值不同。一般情况下，不断扩容，单个桶很长的场景还是比较少的，下面我们实现就不搞这么复杂了，这个解决极端场景的思路，大家了解一下。
C++ 哈希
m0_61548909的博客
08-27 3129
在 C++98 中， STL 提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 $log_2N$，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11 中， STL 又提供了 4 个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，本文中只对unordered_map 和 unordered_set 进行介绍，unordered_multimap和
【C++】哈希（hash）
m0_72563041的博客
05-15 1751
哈希概念，哈希冲突，哈希函数
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值