unordered系列关联式容器
unordered_map
1.1.1 unordered_map
的介绍
1. unordered_map是存储<key, value>键值对的关联式容器,其允许通过keys快速的索引到与其对应的value。
2. 在unordered_map中,键值通常用于惟一地标识元素,而映射值是一个对象,其内容与此键关联。键和映射值的类型可能不同。
3. 在内部,unordered_map没有对<kye, value>按照任何特定的顺序排序, 为了能在常数范围内找到key所对应的value,unordered_map将相同哈希值的键值对放在相同的桶中。
4. unordered_map容器通过key访问单个元素要比map快,但它通常在遍历元素子集的范围迭代方面效率较低。
5. unordered_maps实现了直接访问操作符(operator[]),它允许使用key作为参数直接访问value
6. 它的迭代器至少是前向迭代器。
unordered_map的接口说明
函数声明
| 功能介绍 |
构造不同格式的
unordered_map
对象
|
unordered_map的容量
函数声明
| 功能介绍 |
bool empty() const
| 检测unordered_map是否为空 |
size_t size() const
| 获取unordered_map的有效元素个数 |
unordered_map的迭代器
函数声明
| 功能介绍 |
begin
| 返回unordered_map第一个元素的迭代器 |
end
|
返回
unordered_map
最后一个元素下一个位置的迭代器
|
cbegin
|
返回
unordered_map
第一个元素的
const
迭代器
|
cend
|
返回
unordered_map
最后一个元素下一个位置的
const
迭代器
|
unordered_map
的元素访问
函数声明
|
功能介绍
|
返回与
key
对应的
value
,没有一个默认值
|
注意:该函数中实际调用哈希桶的插入操作,用参数key与V()构造一个默认值往底层哈希桶
中插入,如果key不在哈希桶中,插入成功,返回V(),插入失败,说明key已经在哈希桶中,
将key对应的value返回。
unordered_map的查询
函数声明
|
功能介绍
|
返回
key
在哈希桶中的位置
| |
返回哈希桶中关键码为
key
的键值对的个数
|
注意:unordered_map中key是不能重复的,因此count函数的返回值最大为1
unordered_map的修改操作
函数声明
|
功能介绍
|
insert
|
向容器中插入键值对
|
erase
|
删除容器中的键值对
|
void clear()
|
清空容器中有效元素个数
|
void swap(unordered_map&)
|
交换两个容器中的元素
|
unordered_map的桶操作
函数声明
| 功能介绍 |
size_t bucket_count()const
|
返回哈希桶中桶的总个数
|
size_t bucket_size(size_t n)const
|
返回
n
号桶中有效元素的总个数
|
size_t bucket(const K& key)const
|
返回元素
key
所在的桶号
|
unordered_set
底层结构
unordered
系列的关联式容器之所以效率比较高,是因为其底层使用了哈希结构。
哈希概念
顺序结构以及平衡树
中,元素关键码与其存储位置之间没有对应的关系,因此在
查找一个元素
时,必须要经过关键码的多次比较
。
顺序查找时间复杂度为
O(N)
,平衡树中为树的高度,即
O(),搜索的效率取决于搜索过程中元素的比较次数
理想的搜索方法:可以
不经过任何比较,一次直接从表中得到要搜索的元素
。
如果构造一种存储结构,通过某种函数
(hashFunc)
使元素的存储位置与它的关键码之间能够建立
一一映射的关系,那么在查找时通过该函数可以很快找到该元素
当向该结构中:
插入元素
根据待插入元素的关键码,以此函数计算出该元素的存储位置并按此位置进行存放
搜索元素
对元素的关键码进行同样的计算,把求得的函数值当做元素的存储位置,在结构中按此位置取元素比较,若关键码相等,则搜索成功
该方式即为
哈希(散列)方法
,
哈希方法中使用的转换函数称为哈希
(
散列
)
函数,构造出来的结构称
为哈希表
(Hash Table)(
或者称散列表
)
例如:数据集合 {1 , 7 , 6 , 4 , 5 , 9} ;哈希函数设置为: hash(key) = key % capacity ; capacity 为存储元素底层空间总的大小。
哈希冲突
对于两个数据元素的关键字
和
(i != j)
,有
!=
,但有:
Hash() ==Hash(),即:
不同关键字通过相同哈希哈数计算出相同的哈希地址,该种现象称为哈希冲突
或哈希碰撞
。
把具有不同关键码而具有相同哈希地址的数据元素称为
“
同义词
”
。发生哈希冲突该如何处理呢?
哈希函数
引起哈希冲突的一个原因可能是:
哈希函数设计不够合理
。
哈希函数设计原则
:
- 哈希函数的定义域必须包括需要存储的全部关键码,而如果散列表允许有m个地址时,其值
- 域必须在0到m-1之间
- 哈希函数计算出来的地址能均匀分布在整个空间中
- 哈希函数应该比较简单
常见哈希函数
1.
直接定址法
--(
常用
)
取关键字的某个线性函数为散列地址:
Hash
(
Key
)
= A*Key + B
优点:简单、均匀
缺点:需要事先知道关键字的分布情况
使用场景:适合查找比较小且连续的情况
2.
除留余数法
--(
常用
)
设散列表中允许的
地址数为
m
,取一个不大于
m
,但最接近或者等于
m
的质数
p
作为除数,
按照哈希函数:
Hash(key) = key% p(p<=m),
将关键码转换成哈希地址
3.
平方取中法
--(
了解
)
假设关键字为
1234
,对它平方就是
1522756
,抽取中间的
3
位
227
作为哈希地址;再比如关键字为4321
,对它平方就是
18671041
,抽取中间的
3
位
671(
或
710)
作为哈希地址
平方取中法比较适合:不知道关键字的分布,而位数又不是很大的情况
4.
折叠法
--(
了解
)
折叠法是将关键字从左到右分割成位数相等的几部分
(
最后一部分位数可以短些
)
,然后将这几部分叠加求和,并按散列表表长,取后几位作为散列地址。
折叠法适合事先不需要知道关键字的分布,适合关键字位数比较多的情况
5.
随机数法
--(
了解
)
选择一个随机函数,取关键字的随机函数值为它的哈希地址,即
H(key) = random(key),
其中 random为随机数函数。
通常应用于关键字长度不等时采用此法
6.
数学分析法
--(
了解
)
设有
n
个
d
位数,每一位可能有
r
种不同的符号,这
r
种不同的符号在各位上出现的频率不一定相同,可能在某些位上分布比较均匀,每种符号出现的机会均等,在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小,选择其中各种符号分布均匀的若干位作为散列地址。例如:
哈希冲突解决
解决哈希冲突
两种常见的方法是:
闭散列
和
开散列
闭散列
闭散列:也叫开放定址法,当发生哈希冲突时,如果哈希表未被装满,说明在哈希表中必然还有
空位置,那么可以把
key
存放到冲突位置中的
“
下一个
”
空位置中去。
那如何寻找下一个空位置呢
线性探测
比如
2.1
中的场景,现在需要插入元素
44
,先通过哈希函数计算哈希地址,
hashAddr
为
4
,
因此
44
理论上应该插在该位置,但是该位置已经放了值为
4
的元素,即发生哈希冲突。
线性探测:从发生冲突的位置开始,依次向后探测,直到寻找到下一个空位置为止
。
插入
- 通过哈希函数获取待插入元素在哈希表中的位置
- 如果该位置中没有元素则直接插入新元素,如果该位置中有元素发生哈希冲突,
- 使用线性探测找到下一个空位置,插入新元素
删除
采用闭散列处理哈希冲突时,不能随便物理删除哈希表中已有的元素,若直接删除元素
会影响其他元素的搜索
。比如删除元素
4
,如果直接删除掉,
44
查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素
。
线性探测优点:实现非常简单,
线性探测缺点:
一旦发生哈希冲突,所有的冲突连在一起,容易产生数据
“
堆积
”
,即:不同
关键码占据了可利用的空位置,使得寻找某关键码的位置需要许多次比较,导致搜索效率降
低
。如何缓解呢?
二次探测
线性探测的缺陷是产生冲突的数据堆积在一块,这与其找下一个空位置有关系,因为找空位
置的方式就是挨着往后逐个去找,因此二次探测为了避免该问题,
找下一个空位置的方法
为:
= ( + )% m,
或者:
= ( - )% m
。其中:
i =
1,2,3…
,
是通过散列函数
Hash(x)
对元素的关键码
key
进行计算得到的位置,
m
是表
的大小。
对于
2.1
中如果要插入
44
,产生冲突,使用解决后的情况为:
研究表明:
当表的长度为质数且表装载因子
a
不超过
0.5
时,新的表项一定能够插入,而且任
何一个位置都不会被探查两次。因此只要表中有一半的空位置,就不会存在表满的问题。在
搜索时可以不考虑表装满的情况,但在插入时必须确保表的装载因子
a
不超过
0.5
,
如果超出
必须考虑增容。
因此:闭散列最大的缺陷就是空间利用率比较低,这也是哈希的缺陷。
#include<vector>
template<class K>
struct HashFunc
{
size_t operator()(const K& key)
{
return (size_t)key;
}
};
// 特化
template<>
struct HashFunc<string>
{
// abcd
// bcad
// aadd
// BKDR
size_t operator()(const string& key)
{
size_t hash = 0;
for (auto ch : key)
{
hash *= 131;
hash += ch;
}
return hash;
}
};
namespace open_address
{
enum State
{
EMPTY,
EXIST,
DELETE
};
template<class K, class V>
struct HashData
{
pair<K, V> _kv;
State _state = EMPTY;
};
template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
public:
HashTable()
{
_tables.resize(10);
}
bool Insert(const pair<K, V>& kv)
{
if (Find(kv.first))
return false;
// 扩容
if (_n * 10 / _tables.size() >= 7)
{
//size_t newsize = _tables.size() * 2;
//vector<HashData<K, V>> newtables(newsize);
旧表重新计算负载到新表
//for (size_t i = 0; i < _tables.size(); i++)
//{}
HashTable<K, V, Hash> newHT;
newHT._tables.resize(_tables.size() * 2);
// 旧表重新计算负载到新表
for (size_t i = 0; i < _tables.size(); i++)
{
if (_tables[i]._state == EXIST)
{
newHT.Insert(_tables[i]._kv);
}
}
_tables.swap(newHT._tables);
}
Hash hs;
size_t hashi = hs(kv.first) % _tables.size();
// 线性探测
while (_tables[hashi]._state == EXIST)
{
++hashi;
hashi %= _tables.size();
}
_tables[hashi]._kv = kv;
_tables[hashi]._state = EXIST;
++_n;
return true;
}
HashData<K, V>* Find(const K& key)
{
Hash hs;
size_t hashi = hs(key) % _tables.size();
// 线性探测
while (_tables[hashi]._state != EMPTY)
{
if (_tables[hashi]._state == EXIST &&
_tables[hashi]._kv.first == key)
{
return &_tables[hashi];
}
++hashi;
hashi %= _tables.size();
}
return nullptr;
}
bool Erase(const K& key)
{
HashData<K, V>* ret = Find(key);
if (ret == nullptr)
{
return false;
}
else
{
ret->_state = DELETE;
--_n;
return true;
}
}
private:
vector<HashData<K, V>> _tables;
size_t _n = 0; // 有效数据个数
};
}
开散列
开散列概念
开散列法又叫链地址法
(
开链法
)
,首先对关键码集合用散列函数计算散列地址,具有相同地
址的关键码归于同一子集合,每一个子集合称为一个桶,各个桶中的元素通过一个单链表链
接起来,各链表的头结点存储在哈希表中
。
从上图可以看出,
开散列中每个桶中放的都是发生哈希冲突的元素
。
开散列增容
桶的个数是一定的,随着元素的不断插入,每个桶中元素的个数不断增多,极端情况下,可能会导致一个桶中链表节点非常多,会影响的哈希表的性能,因此在一定条件下需要对哈希表进行增容,那该条件怎么确认呢?开散列最好的情况是:每个哈希桶中刚好挂一个节点,再继续插入元素时,每一次都会发生哈希冲突,因此,在元素个数刚好等于桶的个数时,可以给哈希表增容
开散列的思考
只能存储
key
为整形的元素,其他类型怎么解决
利用仿函数即可
开散列与闭散列比较
应用链地址法处理溢出,需要增设链接指针,似乎增加了存储开销 。事实上: 由于开地址法必须保持大量的空闲空间以确保搜索效率,如二次探查法要求装载因子 a <= 0.7 ,而表项所占空间又比指针大的多,所以使用链地址法反而比开地址法节省存储空间。
模拟实现
HashTable.h
#include<vector>
template<class K>
struct HashFunc
{
size_t operator()(const K& key)
{
return (size_t)key;
}
};
// 特化
template<>
struct HashFunc<string>
{
// abcd
// bcad
// aadd
// BKDR
size_t operator()(const string& key)
{
size_t hash = 0;
for (auto ch : key)
{
hash *= 131;
hash += ch;
}
return hash;
}
};
namespace hash_bucket
{
template<class T>
struct HashNode
{
T _data;
HashNode<T>* _next;
HashNode(const T& data)
:_data(data)
,_next(nullptr)
{}
};
// 前置声明
template<class K, class T, class KeyOfT, class Hash>
class HashTable;
//template<class K, class T, class KeyOfT, class Hash>
//struct __HTIterator
//{
// typedef HashNode<T> Node;
// typedef __HTIterator<K, T, KeyOfT, Hash> Self;
// Node* _node;
// HashTable<K, T, KeyOfT, Hash>* _pht;
// __HTIterator(Node* node, HashTable<K, T, KeyOfT, Hash>* pht)
// :_node(node)
// ,_pht(pht)
// {}
// T& operator*()
// {
// return _node->_data;
// }
// Self& operator++()
// {
// if (_node->_next)
// {
// // 当前桶没走完,找当前桶的下一个节点
// _node = _node->_next;
// }
// else
// {
// // 当前桶走完了,找下一个不为空的桶的第一个节点
// KeyOfT kot;
// Hash hs;
// size_t i = hs(kot(_node->_data)) % _pht->_tables.size();
// ++i;
// for (; i < _pht->_tables.size(); i++)
// {
// if (_pht->_tables[i])
// break;
// }
// if (i == _pht->_tables.size())
// {
// // 所有桶都走完了,最后一个的下一个用nullptr标记
// _node = nullptr;
// }
// else
// {
// _node = _pht->_tables[i];
// }
// }
// return *this;
// }
// bool operator!=(const Self& s)
// {
// return _node != s._node;
// }
//};
template<class K, class T, class KeyOfT, class Hash>
class HashTable
{
typedef HashNode<T> Node;
public:
// 友元声明
/*template<class K, class T, class KeyOfT, class Hash>
friend struct __HTIterator;*/
// 内部类
template<class Ptr, class Ref>
struct __HTIterator
{
typedef HashNode<T> Node;
typedef __HTIterator Self;
Node* _node;
const HashTable* _pht;
__HTIterator(Node* node, const HashTable* pht)
:_node(node)
, _pht(pht)
{}
Ref operator*()
{
return _node->_data;
}
Ptr operator->()
{
return &_node->_data;
}
Self& operator++()
{
if (_node->_next)
{
// 当前桶没走完,找当前桶的下一个节点
_node = _node->_next;
}
else
{
// 当前桶走完了,找下一个不为空的桶的第一个节点
KeyOfT kot;
Hash hs;
size_t i = hs(kot(_node->_data)) % _pht->_tables.size();
++i;
for (; i < _pht->_tables.size(); i++)
{
if (_pht->_tables[i])
break;
}
if (i == _pht->_tables.size())
{
// 所有桶都走完了,最后一个的下一个用nullptr标记
_node = nullptr;
}
else
{
_node = _pht->_tables[i];
}
}
return *this;
}
bool operator!=(const Self& s)
{
return _node != s._node;
}
};
typedef __HTIterator<T*, T&> iterator;
typedef __HTIterator<const T*, const T&> const_iterator;
iterator begin()
{
for (size_t i = 0; i < _tables.size(); i++)
{
Node* cur = _tables[i];
if (cur)
{
// this -> HashTable*
return iterator(cur, this);
}
}
return end();
}
iterator end()
{
return iterator(nullptr, this);
}
const_iterator begin() const
{
for (size_t i = 0; i < _tables.size(); i++)
{
Node* cur = _tables[i];
if (cur)
{
// this -> const HashTable*
return const_iterator(cur, this);
}
}
return end();
}
const_iterator end() const
{
return const_iterator(nullptr, this);
}
HashTable()
{
_tables.resize(10, nullptr);
_n = 0;
}
~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;
}
}
pair<iterator, bool> Insert(const T& data)
{
KeyOfT kot;
iterator it = Find(kot(data));
if (it != end())
return make_pair(it, false);
Hash hs;
// 扩容
// 负载因子为1时扩容
if (_n == _tables.size())
{
//HashTable<K, V> newHT;
//newHT._tables.resize(_tables.size() * 2);
旧表重新计算负载到新表
//for (size_t i = 0; i < _tables.size(); i++)
//{
// Node* cur = _tables[i];
// while (cur)
// {
// newHT.Insert(cur->_kv);
// cur = cur->_next;
// }
//}
//_tables.swap(newHT._tables);
vector<Node*> newTables(_tables.size()*2, nullptr);
for (size_t i = 0; i < _tables.size(); i++)
{
Node* cur = _tables[i];
while (cur)
{
Node* next = cur->_next;
// 头插新表的位置
size_t hashi = hs(kot(cur->_data)) % newTables.size();
cur->_next = newTables[hashi];
newTables[hashi] = cur;
cur = next;
}
_tables[i] = nullptr;
}
_tables.swap(newTables);
}
size_t hashi = hs(kot(data)) % _tables.size();
Node* newnode = new Node(data);
// 头插
newnode->_next = _tables[hashi];
_tables[hashi] = newnode;
++_n;
return make_pair(iterator(newnode, this), true);
}
iterator Find(const K& key)
{
KeyOfT kot;
Hash hs;
size_t hashi = hs(key) % _tables.size();
Node* cur = _tables[hashi];
while (cur)
{
if (kot(cur->_data) == key)
{
return iterator(cur, this);
}
cur = cur->_next;
}
return end();
}
bool Erase(const K& key)
{
KeyOfT kot;
Hash hs;
size_t hashi = hs(key) % _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;
}
else
{
prev = cur;
cur = cur->_next;
}
}
return false;
}
private:
vector<Node*> _tables; // 指针数组
size_t _n;
//vector<list<pair<K, V>>> _tables;
};
}
my_unordered_map.h
namespace bit
{
template<class K, class V, class Hash = HashFunc<K>>
class unordered_map
{
struct MapKeyOfT
{
const K& operator()(const pair<K, V>& kv)
{
return kv.first;
}
};
public:
typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT, Hash>::iterator iterator;
iterator begin()
{
return _ht.begin();
}
iterator end()
{
return _ht.end();
}
V& operator[](const K& key)
{
pair<iterator, bool> ret = insert(make_pair(key, V()));
return ret.first->second;
}
pair<iterator, bool> insert(const pair<K, V>& kv)
{
return _ht.Insert(kv);
}
private:
hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT, Hash> _ht;
};
}
my_unordered_set.h
namespace bit
{
template<class K, class Hash = HashFunc<K>>
class unordered_set
{
struct SetKeyOfT
{
const K& operator()(const K& key)
{
return key;
}
};
public:
typedef typename hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::iterator iterator;
typedef typename hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::const_iterator const_iterator;
iterator begin()
{
return _ht.begin();
}
iterator end()
{
return _ht.end();
}
const_iterator begin() const
{
return _ht.begin();
}
const_iterator end() const
{
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:
hash_bucket::HashTable<K, const K, SetKeyOfT, Hash> _ht;
};
}