目录
1.哈希概念
顺序结构以及平衡树中,元素关键码与其存储位置之间没有对应的关系,因此在查找一个元素时,必须要经过关键码的多次比较。顺序查找时间复杂度为O(N),平衡树中为树的高度,即O( logN),搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法:可以不经过任何比较,一次直接从表中得到要搜索的元素。 如果构造一种存储结构,通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系,那么在查找时通过该函数可以很快找到该元素。
插入元素:根据待插入元素的关键码,以此函数计算出该元素的存储位置并按此位置进行存放
搜索元素:对元素的关键码进行同样的计算,把求得的函数值当做元素的存储位置,在结构中按此位置取元素比 较,若关键码相等,则搜索成功。该方式即为哈希(散列)方法,哈希方法中使用的转换函数称为哈希(散列)函数,构造出来的结构称为哈希表 (Hash Table)(或者称散列表)。
哈希函数设置为:hash(key) = key % capacity; capacity为存储元素底层空间总的大小。
2.哈希冲突
对于两个数据元素的关键字ki和kj(i!=j),有i!=j,但有:Hash(ki) == Hash(kj),即:不同关键字通过 相同哈希函数计算出相同的哈希地址,该种现象称为哈希冲突或哈希碰撞。
把具有不同关键码而具有相同哈希地址的数据元素成为同义词。
如何解决冲突呢?
3.哈希函数
哈希函数设计原则:
- 哈希函数的定义域必须包括全部的关键码,散列表大小为m时,值域为0~m-1之间。
- 哈希函数计算出来的地址能均匀的分布在整个空间。
- 哈希函数比较简单
常见的哈希函数方法
1.直接定址法
取关键字的某个线性函数为散列地址:Hash(Key)= A*Key + B 优点:简单、均匀 缺点:需要事先知道关键字的分布情况使用场景:适合查找比较小且连续的情况。
2.除留余数法
设散列表中允许的地址数为m,取一个不大于m,但最接近或者等于m的质数p作为除数,按照哈希函数:Hash(key) = key% p(p<=m),将关键码转换成哈希地址。
一般常用的就是这两种,其他的方法这里就不讨论了。
4.哈希冲突的解决
常见的有两种方法:闭散列和开散列
4.1 闭散列
闭散列也叫开放定址法,当发生哈希冲突时,如果哈希表未被装满,说明在哈希表中必然还有空位置,那 么可以把key存放到冲突位置中的“下一个” 空位置中去。那如何寻找下一个空位置呢?
4.1.1 线性探测
从发生冲突的位置开始,依次向后探测,直到寻找到下一个空位置为止。
-
插入
通过哈希函数获取到待插入元素在哈希表中的位置
如果该位置中没有元素则直接插入新元素,若有元素则,依次往后查找,直到找到空位置插入。
- 删除
采用闭散列进行删除元素时,不能直接的物理删除元素,因为这样有可能会影响之后的其他元素的搜索。比如上图中删除4,若直接删除则在查找44这个元素时,不能正确的查找到。因此在删除元素时一时采用一种逻辑删除的方式。设置一个标记。
//哈希表给每个空间一个标记
enum State{EXITS,EMPTY,DELETE};
下面为仿函数
template<class K>
struct SetKeyOfT
{
const K& operator()(const K& key)
{
return key;
}
};
线性探测的实现
//我们为了实现复用的操作,使用了模板的形式,KeyOfT为一个仿函数,为了区分是key与pair
template<class K,class T,class KeyOfT>
template<class T>
struct HahData
{
T _data;
State _state;//进行逻辑删除的标记
}
class HashTable
{
publid:
//插入
bool Insert(const T& d)
{
KeyOfT koft;
//增容 当负载因子>=0.7时增容
//1.开一个二倍的空间出来
//2.将数据映射到新表
//3.释放旧表的空间
if(_tables.size()==0||_num*10/_tables.size()>=7)
{
vector<HashData<T>> newtables;
//一开始是0的话,则给一个厨师大小10
size_t newsize = _tables.size()==0?10:_tables.size()*2;
newtables.resize(newsize);
for(size_t i=0;i<_tables.size();i++)
{
if(_tables[i]._state==EXITS)
{
//计算在新表中的位置 并解决冲突
size_t index = koft(_tables[i]._data)%newtables.size();
//冲突 则往后移位
while(newtables[index]._state==EXITS)
{
index++;
if(index==newtables.size())
index=0;
}
newtables[index]=_tables[i];
}
}
_tables.swap(newtables);
}
size_t index = koft(d)%_tables.size();
while(_tables[index]._state==EXITS)
{
//如果要插入的元素已经存在 则插入失败
if(koft(_tables[index]._data)==koft(d))
return false;
index++;
if(index==_tabels.size())
index=0;
}
_tables[index]._data=d;
_tables[index]._state=EXITS;
_num++;
return true;
}
//查找
HashData<T>* Find(const K& key)
{
KeyOfT koft;
size_t index = koft(key)&_tables.size();
while(_tables[index]._state!=EMPTY)
{
if(_tables[index]._state==DELETE&&koft(_tables[index]._data)==koft(key))
return nullptr;
else if(_tables[index]._state==EXITS&&koft(_tables[index]._data)==koft(key))
return &_tables[index];
index++;
if(index==_tables.size())
index=0;
}
return nullptr;
}
//删除
bool Erase(const K& key)
{
HashData<T>* ret = Find(key);
if(ret)
{
ret->_state=DELETE;
return true;
}
else
return false;
}
private:
vector<HashData<T>> _tables;
size_t _num;
};
下面为对线性探测进行测试的代码与结果
void testHashTable()
{
HashTable<int, int, SetKeyOfT<int>> ht;
ht.Insert(4);
ht.Insert(14);
ht.Insert(24);
ht.Insert(5);
ht.Insert(15);
ht.Insert(25);
ht.Insert(6);
ht.Insert(16);
}
在插入第八个数据时,哈希表进行扩容 ,并将数据映射到新表中。
思考:哈希表什么情况下进行扩容?如何扩容?
散列表的载荷因子定义为: α = 填入表中的元素个数 /散列表的长度
α是散列表装满程度的标志因子。由于表长是定值,α与“填入表中的元素个数”成正比,所以,α越大,表明填入表中的元素越多,产生冲突的可能性就越大:反之,α越小,标明填入表中的元素越少,产生冲突的可能性就越小。实际上,散列表的平均查找长度是载荷因子α的函数,只是不同处理冲突的方法有不同的函数。
对于开放定址法,荷载因子是特别重要因素,应严格限制在0,7-0.8以下。超过0.8,查表时的CPU缓存不命中(cachemissing)按照指数曲线上升。因此,一些采用开放定址法的hash库,如Java的系统库限制了荷载因子为0.75,超过此值将resize散列表。
4.1.2 二次探测
线性探测的缺陷是产生冲突的数据堆积在一块,这与其找下一个空位置有关系,因为找空位置的方式就是挨着往后逐个去找,因此二次探测为了避免该问题,找下一个空位置的方法为:Hi = (H0 + i^2)%m, 或者: Hi= (H0 -i^2 )% m。其中:i = 1,2,3…, 是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置,m是表的大小。对于上面如果要插入44,产生冲突,使用解决后的情况为:
二次探测的代码实现与线性探测大致相同,只是在映射时有所区别
二次探测的代码实现
//数据的状态信息
enum State { EXITS, DELETE, EMPTY };
//哈希表的存储的信息
template<class T>
struct HashData
{
T _data;
State _state;
};
template<class K, class T, class KeyOfT>
class HashTable
{
public:
//插入
bool Insert(const T& d)
{
KeyOfT koft;
//增容
if (_tables.size() == 0 || _num * 10 / _tables.size() >= 7)
{
vector<HashData<T>> newtables;
size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
newtables.resize(newsize);
for (size_t i = 0; i < _tables.size(); i++)
{
if (_tables[i]._state == EXITS)
{
//计算在新表中的位置
size_t start = koft(_tables[i]._data) % newtables.size();
size_t index = start;
int i = 1;
//冲突 寻找下一个位置
while (newtables[index]._state == EXITS)
{
index = start;
index = index + i * i;
index = index % newtables.size();
}
newtables[index] = _tables[i];
}
}
_tables.swap(newtables);
}
size_t start = koft(d) % _tables.size();
size_t index = start;
int i = 1;
while (_tables[index]._state == EXITS)
{
if (koft(_tables[index]._data) == koft(d))
return false;
index = start;
index = index + i * i;
i++;
index = index % _tables.size();
}
_tables[index]._data = d;
_tables[index]._state = EXITS;
_num++;
}
//查找
HashData<T>* Find(const T& key)
{
KeyOfT koft;
size_t start = koft(key) % _tables.size();
size_t index = start;
int i = 1;
while (_tables[index]._state != EMPTY)
{
//若要查找的元素已被删除 则查找失败
if (_tables[index]._state == DELETE && koft(_tables[index]._data) == koft(key))
{
return nullptr;
}
//若要查找的元素存在 则返回他的地址
else if (_tables[index]._state == EXITS && koft(_tables[index]._data) == koft(key))
return &_tables[index];
index = start;
index = index + i * i;
index = index % _tables.size();
}
return nullptr;
}
bool Erase(const K& key)
{
HashData<T>* ret = Find(key);
if (ret)
{
ret->_state = DELETE;
return true;
}
else
return false;
}
private:
vector<HashData<T>> _tables;
size_t _num;
};
下面为二次探测的测试代码与结果
void testHashTable()
{
HashTable<int, int, SetKeyOfT<int>> ht;
ht.Insert(4);
ht.Insert(14);
ht.Insert(24);
ht.Insert(5);
ht.Insert(15);
ht.Insert(25);
ht.Insert(6);
ht.Insert(16);
}
由于线性探测可能会产生一片一片的冲突,采用二次探测会稀疏这种冲突。
研究表明:当表的长度为质数且表装载因子a不超过0.5时,新的表项一定能够插入,而且任何一个位置 都不会被探查两次。因此只要表中有一半的空位置,就不会存在表满的问题。在搜索时可以不考虑表装满的情况,但在插入时必须确保表的装载因子a不超过0.5,如果超出必须考虑增容。
4.2 开散列
拉链法(哈希桶)
开散列法又叫链地址法(拉链法),首先对关键码集合用散列函数计算散列地址,具有相同地址的关键码归于同一子集合,每一个子集合称为一个桶,各个桶中的元素通过一个单链表链接起来,各链表的头结点存储在哈希表中。
插入44后的哈希桶结构如下:
从上图可以看出,开散列中每个桶中放的都是发生哈希冲突的元素。
哈希桶的代码实现
template<class T>
struct HashNode
{
HashNode(const T& data) : _data(data), _next(nullptr)
{}
T _data;
HashNode* _next;
};
template<class K, class T, class KeyOfT>
struct _HashTableIterator
{
typedef HashNode<T> Node;
Node* _node;
};
//仿函数将对应的key转成可以取模的整形
//默认的仿函数直接返回key 因为有的类型可以直接取模
template<class K>
struct _Hash
{
const K& operator()(const K& key)
{
return key;
}
};
//模板特化
template<>
struct _Hash<string>
{
size_t operator()(const string& key)
{
//BKDR hash
size_t hash = 0;
for (size_t i = 0; i < key.size(); i++)
{
hash += 131;
hash += key[i];
}
return hash;
}
};
//有的类型不支持取模,所以给了第四个参数 给转换成整型
template<class K, class T, class KeyOfT, class Hash = _Hash<K>>
class HashTable
{
typedef HashNode<T> Node;
public:
size_t HashFunc(const K& key)
{
Hash hash;
return hash(key);
}
bool Insert(const T& data)
{
KeyOfT koft;
//增容 f负载因子为1时,需要增容
if (_num == _tables.size())
{
vector<Node*> newtables;
size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
newtables.resize(newsize);
//将旧表中的数据添加到新表中 一条链一条链添加
for (size_t i = 0; i < _tables.size(); i++)
{
Node* cur = _tables[i];
while (cur)
{
Node* next = cur->_next;
size_t index = HashFunc(koft(cur->_data)) % newtables.size();
cur->_next = newtables[index];
newtables[index] = cur;
cur = next;
}
_tables[i] = nullptr;
}
_tables.swap(newtables);
}
size_t index = HashFunc(koft(data)) % _tables.size();
//1.先检查这个数据是否在表中,若表中已存在 则返回false
Node* cur = _tables[index];
while (cur)
{
if (koft(cur->_data) == koft(data))
return false;
else
cur = cur->_next;
}
//2.头插到挂的链表中
Node* newnode = new Node(data);
newnode->_next = _tables[index];
_tables[index] = newnode;
_num++;
return true;
}
//查找
Node* Find(const K& key)
{
KeyOfT koft;
size_t index = HashFunc(key) % _tables.size();
Node* cur = _tables[index];
while (cur)
{
if (koft(cur->_data) == koft(key))
{
return cur;
}
else
cur = cur->_next;
}
return nullptr;
}
//删除
bool Erase(const K& key)
{
KeyOfT koft;
size_t index = HashFunc(koft(key)) % _tables.size();
Node* cur = _tables[index];
Node* prev = nullptr;
while (cur)
{
//若当前节点是要删除的节点时
if(koft(cur->_data)==koft(key))
{
//若是第一个节点,删除时略有不同
if (cur->_datacur = _tables[index])
{
_tables[index] = cur->_next;
}
else
{
prev->_next = cur->_next;
}
delete cur;
cur = nullptr;
_num--;
return true;
}
//继续向下找
else
{
prev = cur;
cur = cur->_next;
}
}
return false;
}
private:
vector<HashNode<T>*> _tables;
size_t _num = 0;
};
哈希桶测试代码如下:
void testHashTable()
{
//没有给第四个模板参数,会调用默认参数(缺省值)
HashTable<int, int, SetKeyOfT<int>> ht;
ht.Insert(4);
ht.Insert(14);
ht.Insert(24);
ht.Insert(5);
ht.Insert(15);
ht.Insert(25);
ht.Insert(6);
ht.Insert(16);
ht.Insert(26);
ht.Insert(7);
ht.Insert(27);
ht.Erase(4);
ht.Erase(14);
}
结果
负载因子为1时,进行增容
开散列增容:桶的个数是一定的,随着元素的不断插入,每个桶中元素的个数不断增多,极端情况下,可能会导致一 个桶中链表节点非常多,会影响的哈希表的性能,因此在一定条件下需要对哈希表进行增容,那该条件 怎么确认呢?开散列最好的情况是:每个哈希桶中刚好挂一个节点,再继续插入元素时,每一次都会发 生哈希冲突,因此,在元素个数刚好等于桶的个数时,可以给哈希表增容
开散列的思考
只能存储key为整形的元素,其他类型怎么解决?
其实本文已经在上面的代码中给出了,其它类型该怎么存储。由于最常用的就是整型和字符串型,所以我们在上面的代码中,只给出了整型和字符串型。
对字符串进行取模我们是让它的所有字符的ASCII值相加,并且采用了BKDR的方式进行处理。
还使用了模板特化和缺省值的方法,在实例化哈希表的时候不需要显式的传模板参数。
5.开散列与闭散列比较
应用链地址法处理溢出,需要增设链接指针,似乎增加了存储开销。事实上: 由于开地址法必须保持大 量的空闲空间以确保搜索效率,如二次探查法要求装载因子a <= 0.7,而表项所占空间又比指针大的 多,所以使用链地址法反而比开地址法节省存储空间