unordered系列关联式容器
在C++98中,STL提供了底层为红黑树结构的一系列关联式容器,在查询时效率可达到O(logN) ,即最差情况下需要比较红黑树的高度次,当树中的节点非常多时,查询效率也不理想。最好的查询是,进行很少的比较次数就能够将元素找到。
因此在C++11中,STL又提供了4个unordered系列的关联式容器,这四个容器与红黑树结构的关联式容器使用方式基本类似,只是其底层结构不同。下面就开始依次进行讲解。
unordered_map
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<string, int> mp1;
- 拷贝构造一个容器:
unordered_map<string, int> mp2(mp1);
- 使用迭代器区间构造一个容器:
unordered_map<string, int> mp2(mp1.begin(), mp1.end());
unordered_map的函数接口说明
-
unordered_map的容量:
-
unordered_map的迭代器:
-
unordered_map的元素访问:
注意:针对于[ ]的重载,该函数实际调用哈希桶的插入操作,用参数key与V()构造一个默认值往底层哈希桶中插入,针对插入成功与否,有如下说明:- 如果key不在哈希桶中,插入成功,返回V()。
- 若key已经在哈希桶中,插入失败,将key对应的value返回。
其实和map的[ ]运算符重载的规则没有啥区别。
-
unordered_map的查询:
注意:unordered_map中key是不能重复的,因此count函数的返回值最大为1。 -
unordered_map的修改操作:
-
unordered_map的桶操作:
具体代码示例:
#include<iostream>
#include<utility>
#include<unordered_map>
#include<string>
int main()
{
std::unordered_map<int, std::string> mp;
/*insert插入*/
//1:借助pair构造函数
std::pair<int, std::string> kv(1, "one");
mp.insert(kv);
//2:借助pair构造匿名对象插入
mp.insert(std::pair<int, std::string>(2, "two"));
//3:调用make_pair函数模板插入
mp.insert(std::make_pair(3, "three"));
//4:使用[]运算符重载函数进行插入
mp[4] = "four";
//4:使用{}
mp.insert({ 5, "five" });
/*遍历*/
//1:迭代器遍历
std::unordered_map<int, std::string>::iterator it = mp.begin();
while (it != mp.end())
{
std::cout << it->first << ":" << it->second << " ";
it++;
}
std::cout << std::endl;//1:one 2:two 3:three 4:four 5:five
//2:范围for
for (auto e : mp)
{
std::cout << e.first << ":" << e.second << " ";
}
std::cout << std::endl;//1:one 2:two 3:three 4:four 5:five
/*删除*/
//1:根据key删除
mp.erase(4);
//2:根据迭代器位置删除
std::unordered_map<int, std::string>::iterator pos = mp.find(2);
if (pos != mp.end())
{
mp.erase(pos);
}
for (auto e : mp)
{
std::cout << e.first << ":" << e.second << " ";
}
std::cout << std::endl;//1:one 3:three 5:five
/*修改*/
//1:通过迭代器位置修改
pos = mp.find(5);
if (pos != mp.end())
{
pos->second = "Ⅴ";
}
//2:通过[]修改
mp[3] = "Ⅲ";
for (auto e : mp)
{
std::cout << e.first << ":" << e.second << " ";
}
std::cout << std::endl;//1:one 3:Ⅲ 5:Ⅴ
/*交换*/
std::unordered_map<int, std::string> tmp{ { 2003, "年" }, { 5, "月" }, {7, "日"} };
mp.swap(tmp);
for (auto e : mp)
{
std::cout << e.first << e.second << " ";
}
std::cout << std::endl;//2003年 5月 7日
return 0;
}
unordered_multimap
unordered_multimap和unordered_map的底层都是用哈希表来实现的,所提供的成员函数和unordered_map无显著差异,唯一的区别在于unordered_multimap允许键值冗余,即key值可以是一样的,但是unordered_map不允许。对比如下:
unordered_multimap允许键值冗余,这也就导致其内部的find和count函数和unordered_map中的有所区别,如下:
unordered_set
unordered_set的介绍
1、unordered_set是不按特定顺序存储键值的关联式容器,其允许通过键值快速的索引到对应的元素。
2、在unordered_set中,元素的值同时也是唯一地标识它的key。
3、在内部,unordered_set中的元素没有按照任何特定的顺序排序,为了能在常数范围内找到指定的key,unordered_set将相同哈希值的键值放在相同的桶中。
4、unordered_set容器通过key访问单个元素要比set快,但它通常在遍历元素子集的范围迭代方面效率较低。
5、它的迭代器至少是前向迭代器。(单向)
unordered_set的构造方式
- 构造一个空容器
unordered_set<int> s1;
- 拷贝构造一个容器
unordered_set<int> s2(s1);
- 使用迭代器构造一段区间
string str("hello world");
unordered_set<string> s3(str.begin(), str.end());
unordered_set的函数接口说明
具体代码示例:
#include<iostream>
#include<utility>
#include<unordered_set>
#include<string>
int main()
{
std::unordered_set<int> s;
/*插入*/
s.insert(1);
s.insert(-2);
s.insert(1);
s.insert(5);
s.insert(3);
s.insert(-2);
s.insert(6);
s.insert(4);
/*遍历*/
std::unordered_set<int>::iterator it = s.begin();
while (it != s.end())
{
std::cout << *it << " ";
it++;
}
std::cout << std::endl;//1 5 -2 3 6 4
/*删除*/
//1:根据指定key删除
s.erase(-2);
//2:根据迭代器位置删除
std::unordered_set<int>::iterator pos = s.find(5);
if (pos != s.end())
{
s.erase(pos);
}
for (auto e : s)
{
std::cout << e << " ";
}
std::cout << std::endl;//1 3 6 4
/*交换*/
std::unordered_set<int> tmp{ 100,-200,300,250 };
s.swap(tmp);
for (auto e : s)
{
std::cout << e << " ";
}
std::cout << std::endl;//100 300 -200 250
return 0;
}
unordered_multiset
unordered_multiset和unordered_set的底层都是用哈希表来实现的,所提供的成员函数和unordered_set无显著差异,唯一的区别在于unordered_multiset允许键值冗余,即key值可以是一样的,但是unordered_set不允许。对比如下:
由于unordered_multiset容器允许键值冗余,因此该容器中成员函数find和count的意义与unordered_set容器中的也有所不同:
map/set与unordered_map/unordered_set的区别
set/unordered_set的性能对比
void test_op()
{
int n = 1000000;
std::vector<int> v;
v.reserve(n);
srand(time(0));
for (int i = 0; i < n; ++i)
{
//v.push_back(i);
//v.push_back(rand()+i); // 重复少
v.push_back(rand()); // 重复多
}
/* 插入效率测试 */
size_t begin1 = clock();
std::set<int> s;
for (auto e : v)
{
s.insert(e);
}
size_t end1 = clock();
size_t begin2 = clock();
std::unordered_set<int> us;
for (auto e : v)
{
us.insert(e);
}
size_t end2 = clock();
std::cout << s.size() << std::endl;
std::cout << "set insert:" << end1 - begin1 << std::endl;
std::cout << "unordered_set insert:" << end2 - begin2 << std::endl;
/* 查找效率测试 */
size_t begin3 = clock();
for (auto e : v)
{
s.find(e);
}
size_t end3 = clock();
size_t begin4 = clock();
for (auto e : v)
{
us.find(e);
}
size_t end4 = clock();
std::cout << "set find:" << end3 - begin3 << std::endl;
std::cout << "unordered_set find:" << end4 - begin4 << std::endl;
/* 删除效率测试 */
size_t begin5 = clock();
for (auto e : v)
{
s.erase(e);
}
size_t end5 = clock();
size_t begin6 = clock();
for (auto e : v)
{
us.erase(e);
}
size_t end6 = clock();
std::cout << "set erase:" << end5 - begin5 << std::endl;
std::cout << "unordered_set erase:" << end6 - begin6 << std::endl;
}
总结:当测试数据量较少时,二者差距不大,数据量较大时,用unordered_系列更优。