【C++】---哈希冲突(面试常考点）

最新推荐文章于 2024-02-01 19:09:43 发布

L19002S

最新推荐文章于 2024-02-01 19:09:43 发布

阅读量1.6k

点赞数 2

分类专栏： C++ 文章标签：数据结构

本文链接：https://blog.csdn.net/L19002S/article/details/108032762

版权

C++ 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

哈希冲突

一、何为哈希

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

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

当向该结构中：
插入元素
根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放！

搜索元素
对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)

例如：数据集合{1，7，6，4，5，9}；
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。
在这里插入图片描述
用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快问题：按照上述哈希方式，向集合中插入元素44，会出现什么问题？显而易见的是，出现了哈希冲突！

二、何为哈希冲突

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

三、如何解决哈希冲突

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

1.闭散列

闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。如何寻找下一个空位置成为了解决问题的关键所在！

线性探测

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

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

插入

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

在这里插入图片描述

删除

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

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

线性探测的实现

// 注意：假如实现的哈希表中元素唯一，即key相同的元素不再进行插入
// 为了实现简单，此哈希表中我们将比较直接与元素绑定在一起
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(-1 != index)
 {
 _ht[index]._state = DELETE;
 _size++;
 return true;
 }
 return false;
 }
 size_t Size()const;
 bool Empty() const; 
 void Swap(HashTable<K, V, HF>& ht);
private:
 size_t HashFunc(const K& key)
 {
 return key % _ht.capacity();
 }
private:
 vector<Elem> _ht;
 size_t _size;
};

线性探测优化方案

只能存储key为整形的元素，其他类型怎么解决？

// 哈希函数采用处理余数法，被模的key必须要为整形才可以处理，此处提供将key转化为整形的方法
// 整形数据不需要转化
template<class T>
class DefHashF
{
public:
 size_t operator()(const T& val)
 {
 return val;
 }
};
// key为字符串类型，需要将其转化为整形
class Str2Int
{
public:
 size_t operator()(const string& s)
 {
 const char* str = s.c_str();
 unsigned int seed = 131; // 31 131 1313 13131 131313
 unsigned int hash = 0;
 while (*str)
 {
 hash = hash * seed + (*str++);
 }
 
 return (hash & 0x7FFFFFFF);
 }
};
// 为了实现简单，此哈希表中我们将比较直接与元素绑定在一起
template<class K, class V, class HF>
class HashTable
{
 // ……
private:
 size_t HashFunc(const K& key)
 {
 return HF()(key)%_ht.capacity();
 }
};

除留余数法，最好模一个素数，如何每次快速取一个类似两倍关系的素数？

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

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

二次探测

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

2.开散列

开散列概念

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

开散列实现

template<class V>
struct HashBucketNode
{
 HashBucketNode(const V& data)
 : _pNext(nullptr), _data(data)
 {}
 HashBucketNode<V>* _pNext;
 V _data;
};
// 本文所实现的哈希桶中key是唯一的
template<class V, class HF = DefHashF<T> >
class HashBucket
{
 typedef HashBucketNode<V> Node;
 typedef Node* PNode;
public:
 HashBucket(size_t capacity = 3): _size(0)
 { _ht.resize(GetNextPrime(capacity), nullptr);}
 // 哈希桶中的元素不能重复
 PNode* Insert(const V& data)
 {
 // 确认是否需要扩容。。。
 // _CheckCapacity();
 
 // 1. 计算元素所在的桶号
 size_t bucketNo = HashFunc(data);
 
 // 2. 检测该元素是否在桶中
 PNode pCur = _ht[bucketNo];
 while(pCur)
 {
 if(pCur->_data == data)
 return pCur;
 
 pCur = pCur->_pNext;
 }
 
 // 3. 插入新元素
 pCur = new Node(data);
 pCur->_pNext = _ht[bucketNo];
 _ht[bucketNo] = pCur;
 _size++;
 return pCur;
 }
 // 删除哈希桶中为data的元素(data不会重复)，返回删除元素的下一个节点
 PNode* Erase(const V& data)
 {
 size_t bucketNo = HashFunc(data);
 PNode pCur = _ht[bucketNo];
 PNode pPrev = nullptr, pRet = nullptr;
 
 while(pCur)
 {
 if(pCur->_data == data)
 {
 if(pCur == _ht[bucketNo])
 _ht[bucketNo] = pCur->_pNext;
 else
 pPrev->_pNext = pCur->_pNext;
 
 pRet = pCur->_pNext;
 delete pCur;
 _size--;
 return pRet;
 }
 }
 
 return nullptr;
 }
 PNode* Find(const V& data);
 size_t Size()const;
 bool Empty()const;
 void Clear();
 bool BucketCount()const;
 void Swap(HashBucket<V, HF>& ht;
 ~HashBucket();
private:
 size_t HashFunc(const V& data);
private:
 vector<PNode*> _ht;
 size_t _size; // 哈希表中有效元素的个数
}；

开散列增容

桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，可能会导致一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希表进行增容，那该条件怎么确认呢？开散列最好的情况是：每个哈希桶中刚好挂一个节点，再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容！

void _CheckCapacity()
{
 size_t bucketCount = BucketCount();
 if(_size == bucketCount)
 {
 HashBucket<V, HF> newHt(bucketCount);
 for(size_t bucketIdx = 0; bucketIdx < bucketCount; ++bucketIdx)
 {
 PNode pCur = _ht[bucketIdx];
 while(pCur)
 {
 // 将该节点从原哈希表中拆出来
 _ht[bucketIdx] = pCur->_pNext;
 
 // 将该节点插入到新哈希表中
 size_t bucketNo = newHt.HashFunc(pCur->_data);
 pCur->_pNext = newHt._ht[bucketNo];
 newHt._ht[bucketNo] = pCur;
 pCur = _ht[bucketIdx];
 }
 }
 
 newHt._size = _size;
 this->Swap(newHt);
 }
}

3.开散列与闭散列比较

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

L19002S

关注

2
点赞
踩
12

收藏

觉得还不错? 一键收藏
打赏
0
评论
【C++】---哈希冲突(面试常考点）

哈希冲突一、何为哈希二、何为哈希冲突三、如何解决哈希冲突1.闭散列线性探测插入删除线性探测的实现线性探测优化方案二次探测2.开散列开散列概念开散列实现开散列增容3.开散列与闭散列比较一、何为哈希顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(log2N )，搜索的效率取决于搜索过程中元素的比较次数。理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。如果构造一种存
复制链接

扫一扫