Cpp || 哈希表

最新推荐文章于 2024-05-28 21:05:06 发布

iTXCode

最新推荐文章于 2024-05-28 21:05:06 发布

阅读量1k

点赞数

分类专栏： Cpp进阶学习

本文链接：https://blog.csdn.net/jack_wang128801/article/details/105742001

版权

Cpp进阶学习专栏收录该内容

25 篇文章 4 订阅

订阅专栏

文章目录

来玩个游戏,找不同

在这里插入图片描述

unordered与有序序列的关联式容器之间的区别

从存储的顺序来说:普通关联式容器(set/map/multimap/multiset)内部存储的顺序是有序的,而unordered系列的容器内部存储的数据是无须的且随机的.
从底层结构来说:普通序列式容器底层是通过封装红黑树来维持关联式容器的有序性,而unordered系列的关联式容器底层是通过封装哈希表的方式维持其特性
unordered系列的关联式容器之所以效率比较高,是因为其底层使用了哈希结构

哈希

一:哈希介绍

1.1:哈希概念

顺序结构以及平衡树中,元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(logN)，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
hash table 可以提供任何有名项的存取操作和删除操作.由于操作对象都是有名项,所以hash table也可以被视为是一种字典结构 ,这种结构的用意在于常数时间之基本操作

1.2:对该结构的操作

插入元素
根据带插入元素的关键码,以此函数计算出该元素的存储位置并按此位置进行存放

例如:将哈希函数设置为:hash(key)=key%capacity;(capacity为存储元素底层空间总的大小)

在这里插入图片描述

该过程中key值通过哈希函数进行计算决定插入位置

搜索元素
对元素的关键码进行同样的计算,把求得的函数值当做元素的存储位置,在结构中按此位置取元素比较,若关键码相等,则搜索成功.

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

那么往上述的列表中插入44会发生什么情况呢?

1.3:哈希冲突

对于两个数据元素的关键字 Ki和 Kj (i != j),有Ki != Kj ，但有：Hash( Ki) == Hash( Kj)，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

向上例中4与44插入的时候,通过哈希函数计算两者要插入的位置相同,发生冲突–>哈希冲突.
那么该怎么解决哈希冲突带来的困扰呢?

1.4:哈希函数

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

1.4.1:哈希函数设计原则

哈希函数的定义域必须包括需要存储的全部关键码,而如果散列表允许有m个地址时,其值域必须在0~m-1之间
哈希函数计算出来的地址能均匀分布在整个空间中
哈希函数应该比较简答

1.4.2:常用的两种哈希函数

1.直接定值法

取关键字的某个线性函数为散列地址:Hash(Key)=A*Key+B

优点:简单、均匀、
缺点:需要事先知道关键字的分布情况,
使用场景:合适查找比较小且连续的情况

2.除留余数法

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

注意

哈希函数设计的越精妙,产生哈希冲突的可能性就越低,但是无法避免哈希冲突的发生

1.5:哈希冲突解决

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

1.5.1:闭散列

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

那如何寻找下一个空位置呢？

解决办法有两种线性探测和除留余数法

1.线性探测:从发生冲突的位置开始,依次往后探测,直到寻找到下一个空位置为止

插入

1.通过哈希函数获取待插入元素的在哈希表中的位置
2.如果该位置中没有元素就直接插入新的元素,如果该位置中有元素会发生哈希冲突,使用线性探测找到下一个空位置,插入新的元素

在插入了元素(1,4,5,6,7,9)之后继续往哈希表中插入新的元素44,插入过程中发现hash(44)结果也为4,而下标为4的位置已经被占用了(发生哈希冲突),所以继续往后寻找合适的位置插入(5,6,7)位置均被占用,但是下标为8的位置还空着,就将44插入到该位置

在这里插入图片描述

删除

采用闲散列处理哈希冲突时,不能随便物理删除哈希表中已有的元素,若直接删除元素会影响其他元素的搜索.比如直接删除元素4,如果直接删除掉,44查找起来可能会受影响.因此线性探测采用标记的伪删除法来删除一个元素

//哈希表每个空间给个标记
//EMPTY此位置为空,EXIST此位置已经有元素,DELETE元素已经删除
enum State{EMPTY,EXIST,DELETE};

2.除留余数法:最好模一个素数,如何每次快速去一个类似两倍关系的素数?

const int PRIMECOUNT = 28;
const size_t primeList[PRIMECOUNT] = {
 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] > primeList[i])
 return primeList[i];
 }
 
 return primeList[i];
 }

3.什么时机进行增容,如何增容?

散列表的载荷因子定义为: α =填入表中的元素个数 / 散列表的长度

α时散列表中装满程度的标志因子,由于表长为定值,α与"填入表中的元素个数" 成正比,所以α越大,表明填入表中的元素就越多,产生冲突的可能性就越大;反之,α越小,表明填入表中的元素越少,产生冲突的可能性就越小,实际上,散列表的平均查找长度是载荷因子α的函数,只是不同处理冲突的方法有不同的函数

对于开放定址法,载荷因子是特别重要因素,应严格限制在0.7-0.8以下,超过0.8查表时的CPU缓存不命中,按照指数曲线上升,因此,一些采用开放定址法的hash库.

void CheckCapacity()
{
 if(_size * 10 / _ht.capacity() >= 7)
 {
 HashTable<K, V, HF> newHt(GetNextPrime(ht.capacity));
 for(size_t i = 0; i < _ht.capacity(); ++i)
 {
 if(_ht[i]._state == EXIST)
 newHt.Insert(_ht[i]._val);
 }
 
 Swap(newHt);
 }
}

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

4.二次探测

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为： Hi= (Ho +i^2 )% m,或者：Hi = (Ho - i ^2)% m。其中：i = 1,2,3…，是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小。如果要插入44，产生冲突，使用解决后的情况为：
在这里插入图片描述

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

因此:闭散列最大的缺陷就是空间利用率比较低,着也是哈希的缺陷

1.5.2:开散列

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

在这里插入图片描述

上图可以看出,开散列中每个桶中放的都是发生哈希冲突的元素

开散列增容

桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，可能会导致一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希表进行增容，那该条件怎么确认呢？

开散列最好的情况是：每个哈希桶中刚好挂一个节点，再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容。

        void CheckCapacity(){
          if(_size==_table.size()){
            size_t newC=_table.size()==0?10:2*_table.size();

            KeyOfValue Kov;
            vector<pNode> newHt;
            //新建一个表,将原来表中的元素赋值到新的表中
            newHt.resize(newC);
            for(size_t i=0;i<_table.size();i++){
              pNode cur=_table[i];

              while(cur){
                pNode next=cur->_next;
                //位置要重新计算
                size_t index=( Kov(cur->_data) )%newHt.size();
                //头插
                cur->_next=newHt[index];
                newHt[index]=cur;
                cur=next;
              }
              _table[i]=nullptr;
            }
            //新表和原来的表进行交换
            _table.swap(newHt);
          }
        }