C++ 哈希

最新推荐文章于 2024-05-13 14:25:08 发布
最新推荐文章于 2024-05-13 14:25:08 发布
阅读量341 收藏 1
点赞数 1
分类专栏： c++学习 文章标签： 散列表 哈希算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lmw3020083657/article/details/129898903
版权

目录

哈希：

哈希表(散列表)：

哈希函数：

哈希冲突：

 闭散列：

闭散列的结构： 

插入数据

查找元素

删除元素

开散列

哈希表结点

迭代器

迭代器结构：

operator++()

operator*()   operator->()   operator!=()

开散列的哈希表

哈希表的结构

仿函数

析构函数

begin()   end()

查找元素（ Find() ）

增加元素（ Insert() ）

删除元素（ Erase() ）

封装unordered_map和unordered_set​​​​​​​

unordered_set

unordered_map

哈希：

通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，我们便可以通过映射关系很快的查找到想要的元素。

哈希表(散列表)：

希表(散列表)是一种数据结构，通过哈希(散列)方法，构造出来的结构称为哈希表(Hash Table)(或者称散列表)，哈希表查找元素的时间复杂度是O(1)。

哈希函数：

通过哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数。

常见的哈希函数：除留余数法：设哈希表中允许的地址数为m，插入的数据为key，则：

key(关键码对应的哈希地址) = key（关键码） %  m

例如：

 将要插入的数据先%数组的大小，找到对应的映射位置插入

哈希冲突：

当我们在插入13时，会发现13对应的位置已经有数据了，则就构成哈希冲突

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

 
闭散列：

闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么通过线性探测，或二次探测的方法，找到key存放到冲突位置中的“下一个” 空位置去。

闭散列的结构： 


enum State //判断数组位置的状态
{
  EMPTY, //空
  EXITS,  //存在
  DELETE,  //删除
};

template<class T>
struct HashData
{
	T _data;
	State _state; //状态
};

template<class K, class T, class KeyOfT> //仿函数，取出数据的关键字
class HashTable
{
	typedef HashData<T> HashData;
public:
	bool Insert(const T& d); //增

	HashTable* Find(const K& key); //查

	bool Erase(const K& key); //改

private:
	vector<HashData> _tables;  //数组
	size_t _num = 0; //存了几个有效数据
};

哈希表中存放着一个数组（存放着结点）和有效数据的个数。

哈希表结点中存放的除了数据，还有一个被标记的状态，方便我们实现增删查改的操作。

插入数据

负载因子：负载因=表的数据/表的大小，衡量哈希表满的程度，表越接近满，插入数据越容易冲突，冲突越多，效率越低。

哈希表并不是满了才增容，开放定制法中，一般负载因子到0.7左右就开始增容

负载因子越小，冲突概率越低，整体效率越高，但是负载因子越小，浪费的空间越大

bool Insert(const T& data)
{
  KeyOfT koft;
  
  //表为空时增容，或者负载营造到0.7时增容，
  if(_tables.size()==0 || _num*10/_tables.size()>=7)
  {
        //定义一个哈希表的对象，将空间开成旧表的2倍
        HashTable<K, T, KeyOfT> newht;
		size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
		newht._tables.resize(newsize);
        
        //遍历旧表的数据,在新表中调用Insert接口，将旧表的元素依次插入的新表
        for (size_t i = 0; i < _tables.size(); ++i)
		{
			if (_tables[i]._state == EXITS)
			{
				newht.Insert(_tables[i]._data);
			}

		}
        //将新表和旧表交换
		_tables.swap(newht._tables);     
  }

  //计算出data中的key在表中映射的位置
  size_t index = koft(data) % _tables.size();
  //找到空的位置
  while (_tables[index]._state == EXITS)
  { 
    //如果插入的元素表中已经有了，则返回false
    if(kofk(_tables[index]._date)==koft(data))
    {
       return false;
    }
    
    ++index;

    if(index==_tables.size())
    {
      index=0;
    }

  }

  //找到插入的位置
  _tables[index]._data = data;
  _tables[index]._state = EXITS;//将状态标记存在
  _num++;

}

查找元素

		HashTable* Find(const K& key)
		{
			KeyOfT koft;
            //元素在表中的映射位置
			size_t index = key % _tables.size();
            //不为空就表示可能还在后面
			while (_tables[index]._state != EMPTY)
			{
				if (koft(_tables[index]._data) == key)
				{
					if (_tables[index]._state == EXITS)
					{
						return &_tables[index];
					}
                    //如果状态是删除，就返回nullptr
					else if (_tables[index]._state == DELETE)
					{
						return nullptr;
					}
				}

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

删除元素

bool Erase(const K& key)
{
    //调用Find()查找元素
	HashData* ret = Find(key);
    //不为空表示元素存在
	if (ret)
	{
        //将删除的元素标记成删除
		ret->_state = DELETE;
		--_num;
		return true;
	}
	else
	{
		return false;
	}
}

闭散列的开发定制法不是一种好的解决方式，因为他时一种我的位置别站了，我就去抢别人的位置的思路。

开散列

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

哈希表结点

 	//结点
    template <class T>
	struct HashNode
	{
		T _data;
		HashNode<T>* _next;

		HashNode(const T& data)
			: _data(data)
			, _next(nullptr)
		{}
	};

哈希表的结点除了存放数据外，还存放这下一个结点的指针。

迭代器

迭代器结构：

    //两个仿函数，KeyOfT是取到关键子，HashFunc是将除整形外的类型转换成可以取%的整形    
    template<class K, class T, class KeyOfT, class HashFunc>
	class __HTIterator
	{
		typedef HashNode<T> Node;
		typedef __HTIterator<K, T, KeyOfT, HashFunc> Self;
		typedef HashTable<K, T, KeyOfT, HashFunc> HT;
	public:
		Node* _node;
		HT* _pht;

		__HTIterator(Node* node, HT* pht)  //构造函数
			: _node(node)
			, _pht(pht)
		{}

        //将运算符重载
		Self& operator++()

		T& operator*()

		T* operator->()

		bool operator!=(const Self& s) const

	};

因为哈希表不是一个连续的结构， 我们没法天然的获取到下一个结点所在的位置，我们需要将哈希表的迭代器封装成一个类，对运算符进行重载。

迭代器中存放着哈希表的结点和哈希表的对象。

operator++()

如何找到迭代器下一个所处的位置呢？ 

如果当前迭代器指向节点的_next不为空：

 如果迭代器所指向的结点的_next不为空，应为我们便可以通过他的_next找到下一个结点。

如果当前迭代器指向节点的_next为空：

如果迭代器所指向的结点的_next为空，我们需要从新计算一下这个桶所在的位置，将桶指向下一个不为Null的桶。

		Self& operator++()
		{
			if (_node->_next)
			{
				_node = _node->_next;
			}
			else
			{
				KeyOfT kot;
				HashFunc hf;
				size_t hashi = hf(kot(_node->_data)) % _pht->_tables.size();
				++hashi;
				// 找下一个不为空的桶
				for (hashi; hashi < _pht->_tables.size(); ++hashi)
				{
					if (_pht->_tables[hashi])
					{
						_node = _pht->_tables[hashi];
						break;
					}
				}

				// 没有找到不为空的桶，用nullptr去做end标识
				if (hashi == _pht->_tables.size())
				{
					_node = nullptr;
				}
			}

			return *this;
		}

operator*()   operator->()   operator!=()

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

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

开散列的哈希表

哈希表的结构

	//两个仿函数，KeyOfT是取到关键子，HashFunc是将除整形外的类型转换成可以取%的整形
    template <class K, class T, class KeyOfT, class HashFunc= DefaultHash<K>>
	class HashTable
	{
       //设置成友缘函数
	   template <class K, class T, class KeyOfT, class HashFunc>
       friend class __HTIterator;

		typedef HashNode<T> Node;
	public:
		typedef __HTIterator<K, T, KeyOfT, HashFunc> iterator;

		iterator begin()   

		iterator end()

		~HashTable()  //析构函数

		pair<iterator, bool> Insert(const T& data)  //增加元素

		iterator Find(const K& key)  //查找元素

		bool Erase(const K& key)  //删除元素
		
	private:
		vector<Node*> _tables; // 指针数组
		size_t _num = 0;
	};

仿函数


template <class K>
struct DefaultHash
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

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

		return hash;
	}

因为我们存的不一定是int 类型，哈希函数采用处理余数法，被%的key必须要为整形才可以处理，此处提供将key转化为整形的方法。

我们将string转换成size_t的类型。

析构函数

将每一个桶中的元素删除，将指针置空

		~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;
			}
		}

begin()   end()


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


	    iterator begin()
		{
            //找到第一个不为空的桶
			for (size_t i = 0; i < _tables.size(); ++i)
			{
				Node* cur = _tables[i];
				if (cur)
				{
					return iterator(cur, this);
				}
			}
			return end();
		}

查找元素（ Find() ）

		iterator Find(const K& key)
		{
			if (_tables.size() == 0)
			{
				return iterator(nullptr, this);
			}

			KeyOfT kot;
			HashFunc hf;

            //查找Key映射的桶的位置
			size_t hashi = hf(key);
			hashi %= _tables.size();

			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
                    //返回cur位置的迭代器
					return iterator(cur, this);
				}

				cur = cur->_next;
			}

			return iterator(nullptr, this);
		}

增加元素（ Insert() ）

如果插入的元素在表中已经存在，则返回表中的相同的元素的位置。

如果插入的元素在表中不存在，则返回新插入表中的元素的位置。

		pair<iterator, bool> Insert(const T& data)
		{
			HashFunc hf;
			KeyOfT kot;

            //通过find()来判断表中有没有和data相同的元素
			iterator pos = Find(kot(data));
			if (pos != nullptr)
			{
                //如果表中已经有了和data相同的元素，则返回表中和data相同的元素的位置
				return make_pair(pos, false);
			}

			//如果插入有效元素个数和数组的大小相同，就增容
			if (_tables.size() == _num)
			{
				size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				//size_t newSize = GetNextPrime(_tables.size());
				if (newSize != _tables.size())
				{
					vector<Node*> newTable;
					newTable.resize(newSize, nullptr);
					for (size_t i = 0; i < _tables.size(); ++i)
					{
						Node* cur = _tables[i];
						while (cur)
						{
							Node* next = cur->_next;
                            //在新表中对应的位置
							size_t hashi = hf(kot(cur->_data)) % newSize;
                            //在新表中头插
							cur->_next = newTable[hashi];
							newTable[hashi] = cur;

							cur = next;
						}

						_tables[i] = nullptr;
					}
                    //将旧表和新表交换
					newTable.swap(_tables);
				}
			}
             
            
			size_t hashi = hf(kot(data));
			hashi %= _tables.size();

			// 头插到对应的桶
			Node* newnode = new Node(data);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;

			++_num;

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

删除元素（ Erase() ）

		bool Erase(const K& key)
		{
			if (_tables.size() == 0)
			{
				return false;
			}

			HashFunc hf;
			KeyOfT kot;
             
            //找到对应的位置
			size_t hashi = hf(key);
			hashi %= _tables.size();

			Node* prev = nullptr;
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
                    //如果要删除的元素是桶中的第一个元素
					if (prev == nullptr)
					{
						_tables[hashi] = cur->_next;
					}
                     //如果要删除的元素不是桶中的第一个元素
					else
					{
						prev->_next = cur->_next;
					}

					delete cur;

					return true;
				}

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

			return false;
		}

封装unordered_map和unordered_set

unordered_map和unordered_set的底层所使用的都是哈希表

unordered_set

namespace MySet
{
	template <class K, class HashFunc = DefaultHash<K>>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
    typedef typename OPEN_HASH::HashTable<K, K, SetKeyOfT, HashFunc>::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_HASH::HashTable<K, K, SetKeyOfT, HashFunc> _ht;
	};
}

unordered_map

namespace MyMap
{
	template<class K, class V, class HashFunc = DefaultHash<K>>
	class unordered_map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename OPEN_HASH::HashTable<K, pair<K, V>, MapKeyOfT, HashFunc>::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_HASH::HashTable<K, pair<K, V>, MapKeyOfT, HashFunc> _ht;
	};
}

lmw3020083657
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 哈希详解
yn_zi的博客
06-28 1852
具体来说，当使用直接定址法时，我们可以通过一个固定的偏移量或者一个简单的数学运算来计算输入值对应的哈希表位置。然而，拉链法也存在一些缺点。在使用拉链法时，通过哈希函数计算键的哈希值，并访问对应的槽。总之，拉链法是一种解决哈希冲突的方法，通过在哈希表的每个槽中存储一个链表来保存具有相同哈希值的键值对。无论是哪种探测方法，在哈希表逐渐接近满的过程中，插入数据的效率会越来越低，因此闭散列哈希表不能满了再增容。进行同样的计算，把求得的函数值当做元素的存储位置，在节后中按此位置取元素比较，若关键码相等，则搜索成功。
C++【初识哈希】
北 海的博客
07-03 7811
哈希（Hash）是一个广泛的概念，其中包括哈希表、哈希冲突、哈希函数等诸多概念，核心为元素（键值）与存储位置（哈希值）之间的映射关系，哈希值可以通过各种哈希函数进行计算，需要尽量确保 “唯一性”，避免冲突，除此之外，哈希函数还可用于区块链中，计算 区块头（Head）中的信息，本文将带你认识哈希，学习其中的各种知识
一篇文章搞懂C++实现哈希算法
最新发布
weixin_73570479的博客
05-13 2372
哈希算法，也称为散列算法，是一种从任意长度的输入数据创建固定大小输出的方法，这种输出通常被称为“哈希值”、“散列值”或简单地“哈希”。在计算机科学中，哈希算法主要用于快速数据查找和数据结构中的高效数据管理，如哈希表。哈希也是加密和数据完整性验证的基础。哈希算法通过一个称为哈希函数的数学过程来运作。这个函数接受输入（称为“预映射值”）并返回一个通常较短、固定长度的哈希值。这个哈希值在理想情况下为每个不同的输入值提供一个唯一的标识（尽管在实际中这并不总是可能的）。
【C++】-- 哈希算法
局部变量和全局变量
09-20 5597
如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的key之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。 向该结构中插入元素和查找元素时： 插入元素：将元素key存放到用hashFunc计算出的元素key的位置。 查找元素：对元素的key进行计算，把用hashFunc计算的函数值当做元素的存储位置，在哈希结构中按此位置取元素比较，若key相等，则查找成功。
C++ hash函数
yudelian的博客
07-30 2540
目录 hash函数介绍： 用途： Hash函数的特性： 参考： hash函数介绍： 哈希函数，又叫散列函数、散列算法，是一种从任何一种数据中创建小的数字“指纹”（也叫做摘要）的方法 用途： 1.快速验证： 生成各种数据的摘要，当比较两个数据是否相等时，只需要比较他们的摘要就可以了 2.防止篡改 ：传递一个数据，要保证它在传递过程中不被篡改，只需要同时传递它的摘要即可。收到数据的人将这个数据重新生成摘要，然后比较传递的摘要和生成的摘要是否相等，如果相等，则说明数据在传递过程中没有被篡改.
C++现成的hash函数
okokisok1的专栏
11-20 2590
一、简介 Hash，一般翻译做"散列"，也有直接音译为"哈希"的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
使用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++ STL容器与常用库函数
妄北y
12-07 5045
C++ STL（STL是提高C++编写效率的一个利器）
哈希表的使用
奔跑の蜗牛
07-27 2238
哈希表一般用于存储键值对即key-val 一般是由数组和链表构成 常用操作 //查找是否存在键值 unordered_map<int,int> hash; hash.find(key)==hash.end(); hash.count(key)==1; 例题 290. Word Pattern 由于C++中的哈希表不能查找某一值的存在，只能查找某一键是否存在，所以C++需要两个哈希表来相互存储。 class Solution { public: //将字符串传入到数组
【C++】哈希应用
m0_69442905的博客
10-15 1786
常见哈希函数，如直接定制，除留余数，平方取中，折叠法等，以及位图的应用，使用C++模拟实现位图。了解布隆过滤器原理，并且模拟实现，对布隆过滤器的性能以及优缺点进行评估，哈希切割介绍
哈希（hash）--C++
qq_63412763的博客
10-04 1124
哈希思想在处理海量数据极具优越性，往后我会进一步探索哈希的应用。今天咱就只讲一些基础的知识，为以后的拓展做个铺垫。👋。
c++ 哈希表find_5.2 5.3 5.4 5.5 哈希函数与分离链接法及开放定址法，再散列
weixin_29514913的博客
01-27 368
template<typename HashedObj>void HashTable<HashedObj>::makeEmpty() { for (auto& thislist : thelists) thislist.clear();}template<typename HashedObj>bool HashTable<HashedObj&gt...
模拟实现哈希表超详解（C++）
m0_67430750的博客
05-15 7181
模拟实现哈希表两万字详解，包括哈希表的闭散列实现和开散列实现，以及迭代器的实现。
C++实现哈希表。
TPON的博客
11-17 6427
C++模拟实现哈希表
C++哈希函数_哈希表_哈希冲突_负载因子_仿函数_针对字符串的模板特化特化_闭散列(线性探测)哈希表_开散列哈希桶的模拟实现(Key_Value模型数组)
dodamce的博客
12-25 1420
文章目录1.哈希中的基本概念哈希函数常见的哈希函数与缺陷哈希表2.哈希冲突哈希冲突的解决方法(闭散列与开散列)闭散列(开放地址法)负载因子C++实现除留余数法闭散列线性探测哈希表(Key_Value模型)开散列(哈希桶/拉链法)C++实现除留余数法开散列哈希桶(Key_Value模型)3.代码位置 1.哈希中的基本概念 哈希函数 之前的二叉搜索树与红黑树以及顺序结构他们的关键字和它的储存位置没有对应关系，所以在查找一个元素时要经过多次的关键字比较。 顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(l

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值