网站建设设计设计,资阳地网站建设,辽宁网站推广,品质好的四字词语✅1主页#xff1a;我的代码爱吃辣#x1f4c3;2知识讲解#xff1a;数据结构——哈希表☂️3开发环境#xff1a;Visual Studio 2022#x1f4ac;4前言#xff1a;哈希是一种映射的思想#xff0c;哈希表即使利用这种思想#xff0c;… ✅1主页我的代码爱吃辣2知识讲解数据结构——哈希表☂️3开发环境Visual Studio 20224前言哈希是一种映射的思想哈希表即使利用这种思想在查找上进行很少的比较次数就能够将元素找到非常的高效在一定程度上效率比红黑树还要强因此在C11中STL又提供了4个unordered系列的关联式容器他们的底层就是哈希。 目录
一.unordered系列关联式容器
1. unordered_map
1.1 unordered_map的构造
1.2unordered_map的容量 1.3unordered_map的迭代器
1.4 unordered_map的元素访问
1.5unordered_map的查询
1.6unordered_map的修改操作 1.2unordered_set
二.哈希
1.哈希概念
2. 哈希冲突
3.哈希冲突解决
三.实现闭散列除留余数法线性探测
1.整体结构
2.插入
3.查询
4.删除
四.开散列
1.开散列实现
2.插入
3.查询
4.删除
5.析构函数
五.完整代码即测试 一.unordered系列关联式容器
在C98中STL提供了底层为红黑树结构的一系列关联式容器在查询时效率可达到 即最差情况下需要比较红黑树的高度次当树中的节点非常多时查询效率也不理想。最好 的查询是进行很少的比较次数就能够将元素找到因此在C11中STL又提供了4个unordered系列的关联式容器这四个容器与红黑树结构的关联式容器使用方式基本类似只是其底层结构不同本文中只对unordered_map和unordered_set进行介绍unordered_multimap和unordered_multiset学生可查看文档介绍。
1. unordered_map
reference-------unordered_map
unordered_map是存储key, value键值对的关联式容器其允许通过keys快速的索引到与其对应的value。在unordered_map中键值通常用于惟一地标识元素而映射值是一个对象其内容与此键关联。键和映射值的类型可能不同。在内部,unordered_map没有对kye, value按照任何特定的顺序排序, 为了能在常数范围内找到key所对应的valueunordered_map将相同哈希值的键值对放在相同的桶中。unordered_map容器通过key访问单个元素要比map快但它通常在遍历元素子集的范围迭代方面效率较低。unordered_maps实现了直接访问操作符(operator[])它允许使用key作为参数直接访问value。它的迭代器至少是前向迭代器。
1.1 unordered_map的构造
函数声明功能介绍unordered_map构造不同格式的unordered_map对象
1.2unordered_map的容量 函数声明功能介绍bool empty() const检测unordered_map是否为空size_t size() const获取unordered_map的有效元素个数 1.3unordered_map的迭代器
函数声明功能介绍begin返回unordered_map第一个元素的迭代器end返回unordered_map最后一个元素下一个位置的迭代器cbegin返回unordered_map第一个元素的const迭代器cend返回unordered_map最后一个元素下一个位置的const迭代器
1.4 unordered_map的元素访问
函数声明功能介绍operator[]返回与key对应的value没有一个默认值
注意该函数中实际调用哈希桶的插入操作用参数key与V()构造一个默认值往底层哈希桶 中插入如果key不在哈希桶中插入成功返回V()插入失败说明key已经在哈希桶中 将key对应的value返回。
1.5unordered_map的查询
函数声明功能介绍iterator find(const K key)返回key在哈希桶中的位置size_t count(const K key)返回哈希桶中关键码为key的键值对的个数
1.6unordered_map的修改操作
函数声明功能介绍insert向容器中插入键值对erase删除容器中的键值对void clear()清空容器中有效元素个数void swap(unordered_map)交换两个容器中的元素 1.2unordered_set
reference-------unordered_set
二.哈希
unordered系列的关联式容器之所以效率比较高是因为其底层使用了哈希结构。
1.哈希概念
顺序结构以及平衡树中元素关键码与其存储位置之间没有对应的关系因此在查找一个元素 时必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)平衡树中为树的高度即 O()搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法可以不经过任何比较一次直接从表中得到要搜索的元素。如果构造一种存储结构通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立 一一映射的关系那么在查找时通过该函数可以很快找到该元素。
当向该结构中
插入元素
根据待插入元素的关键码以此函数计算出该元素的存储位置并按此位置进行存放。
搜索元素
对元素的关键码进行同样的计算把求得的函数值当做元素的存储位置在结构中按此位置取元素比较若关键码相等则搜索成功。 该方式即为哈希(散列)方法哈希方法中使用的转换函数称为哈希(散列)函数构造出来的结构称 为哈希表(Hash Table)(或者称散列表)。 例如数据集合{176459} 哈希函数设置为hash(key) key % capacity; capacity为存储元素底层空间总的大小。 用该方法进行搜索不必进行多次关键码的比较因此搜索的速度比较快 问题按照上述哈希方式向集合中插入元素44会出现什么问题发生位置冲突。
2. 哈希冲突
对于两个数据元素的关键字k1和k2有k1 ! k2但有Hash(k1) Hash(k2)即不同关键字通过相同哈希哈数计算出相同的哈希地址该种现象称为哈希冲突 或哈希碰撞。
把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。
哈希碰撞的产生一部分原因是哈希函数设计的不够合理。
哈希函数设计原则
哈希函数的定义域必须包括需要存储的全部关键码而如果散列表允许有m个地址时其值域必须在0到m-1之间哈希函数计算出来的地址能均匀分布在整个空间中哈希函数应该比较简单 常见哈希函数
1.直接定址法--(常用) 取关键字的某个线性函数为散列地址HashKey A*Key B 优点简单、均匀。 缺点需要事先知道关键字的分布情况。 使用场景适合查找比较小且连续的情况。2. 除留余数法--(常用) 设散列表中允许的地址数为m取一个不大于m但最接近或者等于m的质数p作为除数 按照哈希函数Hash(key) key% p(pm),将关键码转换成哈希地址。
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改成123446)等方法。
数字分析法通常适合处理关键字位数比较大的情况如果事先知道关键字的分布且关键字的若干位分布较均匀的情况。
注意哈希函数设计的越精妙产生哈希冲突的可能性就越低但是无法避免哈希冲突。
3.哈希冲突解决
解决哈希冲突两种常见的方法是闭散列和开散列。
闭散列
闭散列也叫开放定址法当发生哈希冲突时如果哈希表未被装满说明在哈希表中必然还有 空位置那么可以把key存放到冲突位置中的“下一个” 空位置中去。那如何寻找下一个空位置 呢
1. 线性探测
比如下面中的场景现在需要插入元素44先通过哈希函数计算哈希地址hashAddr为4 因此44理论上应该插在该位置但是该位置已经放了值为4的元素即发生哈希冲突。线性探测从发生冲突的位置开始依次向后探测直到寻找到下一个空位置为止。 插入
通过哈希函数获取待插入元素在哈希表中的位置如果该位置中没有元素则直接插入新元素如果该位置中有元素发生哈希冲突使用线性探测找到下一个空位置插入新元素。 删除
采用闭散列处理哈希冲突时不能随便物理删除哈希表中已有的元素若直接删除元素 会影响其他元素的搜索。比如删除元素4如果直接删除掉44查找起来可能会受影 响。因此线性探测采用标记的伪删除法来删除一个元素。
// 哈希表每个空间给个标记
// EMPTY此位置空 EXIST此位置已经有元素 DELETE元素已经删除
enum State{EMPTY, EXIST, DELETE};
三.实现闭散列除留余数法线性探测
1.整体结构 //状态 enum State{ EXIST,EMPTY,DELETE };//数据结点templateclass K, class Vstruct HashDate {HashDate(){}HashDate(pairK,V kv):_kv(kv){}pairK, V _kv;State state EMPTY;};//开放定址法哈希表templateclass K, class Vclass HashTable{typedef HashDateK, V Date;public://插入bool insert(pairK, V kv){}//删除bool erase(const K key){}//查询pairint,bool find(const K key){}private:vectorDate _sh; //数据存储size_t _n 0; //存储数据的个数};
}
2.插入
插入的步骤
计算插入位置线性探测 bool insert(pairK, V kv){//开放定值法线性探测解决冲突//1.计算插入位置int hashi kv.first % _sh.size();int i 1; int hashn hashi;//r如果插入的位置已经有数据了进行线性探测while (_sh[hashn].state EXIST){hashn hashi i;hashn % _sh.size();i;}//探测空位置插入数据_sh[hashn] Date(kv);//修改状态_sh[hashn].state EXIST;_n;return true;}
注意在计算插入位置时我们楚留余数法使用的是表的size而不是capacity是因为我们真正合法插入的位置是size控制的。
扩容
哈希表什么情况下进行扩容如何扩容
这里引入一个新的概念负载因子 我们约定当负载因子达到0.7时就扩容扩容的步骤 bool insert(pairK, V kv){//如果插入的值已经存在if (find(kv.first).second){return false;}//扩容//负载因子为0.7if (_sh.size() 0 || _n * 10 / _sh.size() 7){//1.确定新的容量int newsize _sh.size() 0 ? 10 : _sh.size() * 2;//每一次扩容都要重新插入数据//2.创建新的哈希表HashTableK, V newHash;//3.将原表数据插入进去复用已经实现的逻辑newHash._sh.resize(newsize);for (auto e : _sh){newHash.insert(e._kv);}//最后将新表与旧表交换即可_sh.swap(newHash._sh);}//开放定值法线性探测解决冲突int hashi kv.first % _sh.size();int i 1; int hashn hashi;while (_sh[hashn].state EXIST){hashn hashi i;hashn % _sh.size();i;}_sh[hashn] Date(kv);_sh[hashn].state EXIST;_n;return true;}3.查询
查询步骤
判空探测查找
pairK,bool find(const K key){//如果表中是空的返回坐标和插入falseif (_sh.empty()){return pairK, bool(-1, false);}//计算位置size_t hashi key % _sh.size();int i 1; int hashn hashi;//线性探测直到遇到空while (_sh[hashn].state!EMPTY){if (_sh[hashn].state EXIST _sh[hashn]._kv.first key){//如果探测到存在且键值相等就返回该键值和turereturn pairK, bool(hashn,true);}hashn hashi i;hashn % _sh.size();i;if (hashn hashi){//已经探测一圈回到了原点即没找到return pairK, bool(-1, false);}}//遇到空没找到return pairK, bool(-1, false);}
4.删除 //删除bool erase(const K key){//先查询存在就删除不存在直接返回falsepairint, bool retfind find(key);if (!retfind.second){return false;}//删除后修改状态_sh[retfind.first].state DELETE;return true;}
线性探测优点实现非常简单。 线性探测缺点一旦发生哈希冲突所有的冲突连在一起容易产生数据“堆积”即不同 关键码占据了可利用的空位置使得寻找某关键码的位置需要许多次比较导致搜索效率降 低。如何缓解呢
四.开散列
开散列概念
开散列法又叫链地址法(开链法)首先对关键码集合用散列函数计算散列地址具有相同地 址的关键码归于同一子集合每一个子集合称为一个桶各个桶中的元素通过一个单链表链 接起来各链表的头结点存储在哈希表中。 从上图可以看出开散列中每个桶中放的都是发生哈希冲突的元素。
1.开散列实现 开散列的结点和结构 templateclass K, class Vstruct HashDate{HashDate(pairK, V kv):_kv(kv),_next(nullptr){}pairK, V _kv; //键值对HashDate* _next; //下一个结点的指针};templateclass K,class Vclass Hashbucket{typedef HashDateK, V Date;typedef pairK, V KV;public:bool insert(KV kv){//...}Date* find(const K key){//....}bool erase(const K key){//...}~Hashbucket(){//....}private:vectorDate* _table; //数据存储size_t _n 0; //数据存储个数};
}
2.插入
因为_table的表中存储都是每个结点的指针每一个桶实际上就是一个链表所以对哈希的插入实际就是对链表的头插。
bool insert(KV kv)
{//插入//计算桶的位置size_t hashi kv.first % _table.size();//创建结点Date* newNode new Date(kv);//新节点的next指向头节点newNode-_next _table[hashi];//新插入的结点变成新的头_table[hashi] newNode;_n;
}
扩容
约定当数据个数达到桶的个数时进行扩容
扩容步骤
bool insert(KV kv){//如果待插入的数据已经存在if ( find(kv.first)){return false;}//扩容if (_n _table.size()){//计算新的桶数size_t newsize _table.size() 0 ? 10 : _table.size() * 2;//创建一个新的表vectorDate* newtable;newtable.resize(newsize);//将就表中的结点拿过来注意此处直接拿旧的结点插入新表//而不是拿到数据后创建新的结点,减少不必要的消耗for (auto cur : _table){while (cur){size_t hashi cur-_kv.first % newtable.size();Date* next cur-_next;cur-_next newtable[hashi];newtable[hashi] cur;cur next;}}//新旧表交换_table.swap(newtable);}//插入size_t hashi kv.first % _table.size();Date* newNode new Date(kv);newNode-_next _table[hashi];_table[hashi] newNode;_n;}
3.查询
查询步骤
找到桶遍历桶中数据
找到了返回结点指针没找到返回nullptr Date* find(const K key){//如果表是空的即就是没有一个数据if (_table.empty()){return nullptr;}//1.计算桶的位置size_t hashi key % _table.size();Date* cur _table[hashi];//2.在桶里面遍历查询while (cur){if (cur-_kv.first key){return cur;}cur cur-_next;}return nullptr;}
4.删除
删除归根结底还是链表的删除
删除的步骤
判断在不在表中计算出桶的位置找打待删除结点并记录其前一个结点改变指向释放结点 bool erase(const K key){//1.查找在不在表中if (!find(key)){return false;}//2.计算桶的位置size_t hashi key % _table.size();Date* cur _table[hashi];//记录前驱结点Date* prov nullptr;//3.找到待删除的结点while (cur){if (cur-_kv.first key){if (prov nullptr){_table[hashi] cur-_next; }else{prov-_next cur-_next;}//4.删除改变指向释放结点delete cur;return true;}else{prov cur;cur cur-_next;}}}
5.析构函数
遍历表中每一个桶并对每一个桶进行释放对桶的销毁就是对链表的销毁。 ~Hashbucket(){for (auto cur : _table){while (cur){Date* next cur-_next;delete cur;cur next;}cur nullptr;}}
五.完整代码即测试
#pragma once
#includevector
#includeiostream
using namespace std;namespace HashOpenAdress
{enum State{EXIST,EMPTY,DELETE};templateclass K, class Vstruct HashDate{HashDate(){}HashDate(pairK,V kv):_kv(kv){}pairK, V _kv;State state EMPTY;};templateclass K, class Vclass HashTable{typedef HashDateK, V Date;public:bool insert(pairK, V kv){//如果插入的值已经存在if (find(kv.first).second){return false;}//扩容//负载因子为0.7if (_sh.size() 0 || _n * 10 / _sh.size() 7){//确定新的容量int newsize _sh.size() 0 ? 10 : _sh.size() * 2;//每一次扩容都要重新插入数据HashTableK, V newHash;newHash._sh.resize(newsize);for (auto e : _sh){newHash.insert(e._kv);}_sh.swap(newHash._sh);}//开放定值法线性探测解决冲突int hashi kv.first % _sh.size();int i 1; int hashn hashi;while (_sh[hashn].state EXIST){hashn hashi i;hashn % _sh.size();i;}_sh[hashn] Date(kv);_sh[hashn].state EXIST;_n;return true;}bool erase(const K key){pairint, bool retfind find(key);if (!retfind.second){return false;}_sh[retfind.first].state DELETE;return true;}pairint,bool find(const K key){if (_sh.empty()){return pairint, bool(-1, false);}size_t hashi key % _sh.size();int i 1; int hashn hashi;while (_sh[hashn].state!EMPTY){if (_sh[hashn].state EXIST _sh[hashn]._kv.first key){return pairint,bool(hashn,true);}hashn hashi i;hashn % _sh.size();i;if (hashn hashi){return pairint, bool(-1, false);}}return pairint, bool(-1, false);}private:vectorDate _sh; //数据存储size_t _n 0; //存储数据的个数};
}namespace HashBucket
{templateclass K, class Vstruct HashDate{HashDate(pairK, V kv):_kv(kv),_next(nullptr){}pairK, V _kv;HashDate* _next;};templateclass K,class Vclass Hashbucket{typedef HashDateK, V Date;typedef pairK, V KV;public:bool insert(KV kv){//如果待插入的数据已经存在if ( find(kv.first)){return false;}//扩容if (_n _table.size()){//计算新的桶数size_t newsize _table.size() 0 ? 10 : _table.size() * 2;//创建一个新的表vectorDate* newtable;newtable.resize(newsize);//将就表中的结点拿过来注意此处直接拿旧的结点插入新表//而不是拿到数据后创建新的结点,减少不必要的消耗for (auto cur : _table){while (cur){size_t hashi cur-_kv.first % newtable.size();Date* next cur-_next;cur-_next newtable[hashi];newtable[hashi] cur;cur next;}}//新旧表交换_table.swap(newtable);}//插入size_t hashi kv.first % _table.size();Date* newNode new Date(kv);newNode-_next _table[hashi];_table[hashi] newNode;_n;}Date* find(const K key){//如果表是空的即就是没有一个数据if (_table.empty()){return nullptr;}//1.计算桶的位置size_t hashi key % _table.size();Date* cur _table[hashi];//2.在桶里面遍历查询while (cur){if (cur-_kv.first key){return cur;}cur cur-_next;}return nullptr;}bool erase(const K key){//1.查找在不在表中if (!find(key)){return false;}//2.计算桶的位置size_t hashi key % _table.size();Date* cur _table[hashi];//记录前驱结点Date* prov nullptr;//3.找到待删除的结点while (cur){if (cur-_kv.first key){if (prov nullptr){_table[hashi] cur-_next; }else{prov-_next cur-_next;}//4.删除改变指向释放结点delete cur;return true;}else{prov cur;cur cur-_next;}}}~Hashbucket(){for (auto cur : _table){while (cur){Date* next cur-_next;delete cur;cur next;}cur nullptr;}}private:vectorDate* _table;size_t _n 0;};
}
