关联式容器
在初阶阶段,我们已经接触过
STL
中的部分容器,比如:
vector
、
list
、
deque
、
forward_list(C++11)
等,这些容器统称为序列式容器,因为其底层为线性序列的数据结构,里面
存储的是元素本身。那什么是关联式容器?它与序列式容器有什么区别?
关联式容器
也是用来存储数据的,与序列式容器不同的是,其
里面存储的是
<key, value>
结构的
键值对,在数据检索时比序列式容器效率更高。
键值对
用来表示具有一一对应关系的一种结构,该结构中一般只包含两个成员变量
key
和
value
,
key
代
表键值,
value
表示与
key
对应的信息
。比如:现在要建立一个英汉互译的字典,那该字典中必然
有英文单词与其对应的中文含义,而且,英文单词与其中文含义是一一对应的关系,即通过该应
该单词,在词典中就可以找到与其对应的中文含义。
SGI-STL
中关于键值对的定义:
template < class T1 , class T2 >struct pair{typedef T1 first_type ;typedef T2 second_type ;T1 first ;T2 second ;pair (): first ( T1 ()), second ( T2 ()){}pair ( const T1 & a , const T2 & b ): first ( a ), second ( b ){}};
树形结构的关联式容器
根据应用场景的不桶,
STL
总共实现了两种不同结构的管理式容器:树型结构与哈希结构。
树型结
构的关联式容器主要有四种:
map
、
set
、
multimap
、
multiset
。这四种容器的共同点是:使
用平衡搜索树
(
即红黑树
)
作为其底层结果,容器中的元素是一个有序的序列。下面一依次介绍每一
个容器。
set
set的介绍
翻译:
1. set
是按照一定次序存储元素的容器
2.
在
set
中,元素的
value
也标识它
(value
就是
key
,类型为
T)
,并且每个
value
必须是唯一的。
set
中的元素不能在容器中修改
(
元素总是
const)
,但是可以从容器中插入或删除它们。
3.
在内部,
set
中的元素总是按照其内部比较对象
(
类型比较
)
所指示的特定严格弱排序准则进行
排序。
4. set
容器通过
key
访问单个元素的速度通常比
unordered_set
容器慢,但它们允许根据顺序对
子集进行直接迭代。
5. set
在底层是用二叉搜索树
(
红黑树
)
实现的。
注意:
1.
与
map/multimap
不同,
map/multimap
中存储的是真正的键值对
<key, value>
,
set
中只放
value
,但在底层实际存放的是由
<value, value>
构成的键值对。
2. set
中插入元素时,只需要插入
value
即可,不需要构造键值对。
3. set
中的元素不可以重复
(
因此可以使用
set
进行去重
)
。
4.
使用
set
的迭代器遍历
set
中的元素,可以得到有序序列
5. set
中的元素默认按照小于(升序)来比较
6. set
中查找某个元素,时间复杂度为:
log2n
7. set
中的元素不允许修改
(
为什么
?)
8. set
中的底层使用二叉搜索树
(
红黑树
)
来实现。
set的使用
1.
set
的模板参数列表
T: set
中存放元素的类型,实际在底层存储
<value, value>
的键值对。
Compare
:
set
中元素默认按照小于来比较
Alloc
:
set
中元素空间的管理方式,使用
STL
提供的空间配置器管理
2.
set
的构造
3. set的迭代器
4. set的容量
函数声明
|
功能介绍
|
bool empty ( ) const
|
检测
set
是否为空,空返回
true
,否则返回
true
|
size_type size() const
|
返回
set
中有效元素的个数
|
5. set修改操作
函数声明
|
功能介绍
|
pair<iterator,bool> insert (
const value_type& x )
|
在
set
中插入元素
x
,实际插入的是
<x, x>
构成的
键值对,如果插入成功,返回
<
该元素在
set
中的
位置,
true>,
如果插入失败,说明
x
在
set
中已经
存在,返回
<x
在
set
中的位置,
false>
|
void erase ( iterator position )
|
删除
set
中
position
位置上的元素
|
size_type erase ( const
key_type& x )
|
删除
set
中值为
x
的元素,返回删除的元素的个数
|
void erase ( iterator first,
iterator last )
|
删除
set
中
[first, last)
区间中的元素
|
void swap (
set<Key,Compare,Allocator>&
st );
|
交换
set
中的元素
|
void clear ( )
|
将
set
中的元素清空
|
iterator find ( const
key_type& x ) const
|
返回
set
中值为
x
的元素的位置
|
size_type count ( const
key_type& x ) const
|
返回
set
中值为
x
的元素的个数
|
6. set的使用举例
#include<iostream>
#include<set>
#include<vector>
using namespace std;
void test_set1()
{
// key模型搜索
// 排序+去重
set<int> s1;
s1.insert(1);
s1.insert(11);
s1.insert(3);
s1.insert(1);
s1.insert(4);
s1.insert(2);
set<int>::iterator it = s1.begin();
while (it != s1.end())
{
//*it = 1;
cout << *it << " ";
++it;
}
cout << endl;
vector<int> v = { 3,2,8,1,10,2 };
set<int> s2(v.begin(), v.end());
for (auto e : s2)
{
cout << e << " ";
}
cout << endl;
set<int> s3 = { 3,2,8,1,10,2 };
for (auto e : s3)
{
cout << e << " ";
}
cout << endl;
s3.erase(8);
s3.erase(18);
for (auto e : s3)
{
cout << e << " ";
}
cout << endl;
auto pos = s3.find(10);
if (pos != s3.end())
{
cout << *pos << endl;
s3.erase(pos);
}
else
{
cout << "找不到" << endl;
}
for (auto e : s3)
{
cout << e << " ";
}
cout << endl;
}
void test_set2()
{
std::set<int> myset;
for (int i = 1; i < 10; i++)
myset.insert(i * 10); // 10 20 30 40 50 60 70 80 90
for (auto e : myset)
{
cout << e << " ";
}
cout << endl;
auto itlow = myset.lower_bound(25); // >= x
auto itup = myset.upper_bound(60); // > x
// [30, 70)
myset.erase(itlow, itup); // 10 20 70 80 90
for (auto e : myset)
{
cout << e << " ";
}
cout << endl;
}
multiset
void test_set3()
{
// key模型搜索
// 排序 不去重,允许冗余
//
multiset<int> s1;
s1.insert(1);
s1.insert(11);
s1.insert(3);
s1.insert(1);
s1.insert(4);
s1.insert(2);
s1.insert(4);
s1.insert(2);
s1.insert(1);
s1.insert(2);
s1.insert(1);
multiset<int>::iterator it = s1.begin();
while (it != s1.end())
{
//*it = 1;
cout << *it << " ";
++it;
}
cout << endl;
auto pos = s1.find(2);
while (pos != s1.end() && *pos == 2)
{
cout << *pos << " ";
++pos;
}
}
map
map的介绍
map - C++ Reference (cplusplus.com)
翻译:
1. map
是关联容器,它按照特定的次序
(
按照
key
来比较
)
存储由键值
key
和值
value
组合而成的元
素。
2.
在
map
中,键值
key
通常用于排序和惟一地标识元素,而值
value
中存储与此键值
key
关联的
内容。键值
key
和值
value
的类型可能不同,并且在
map的内部,key与value通过成员类型value_type绑定在一起,为其取别名称为pair:
typedef pair<const key, T> value_type;
3.
在内部,
map
中的元素总是按照键值
key
进行比较排序的。
4. map
中通过键值访问单个元素的速度通常比
unordered_map
容器慢,但
map
允许根据顺序
对元素进行直接迭代
(
即对
map
中的元素进行迭代时,可以得到一个有序的序列
)
。
5. map
支持下标访问符,即在
[]
中放入
key
,就可以找到与
key
对应的
value
。
6. map
通常被实现为二叉搜索树
(
更准确的说:平衡二叉搜索树
(
红黑树
))
。
map的使用
1.
map
的模板参数说明
key:
键值对中
key
的类型
T
: 键值对中
value
的类型
Compare:
比较器的类型,
map
中的元素是按照
key
来比较的,缺省情况下按照小于来比
较,一般情况下
(
内置类型元素
)
该参数不需要传递,如果无法比较时
(
自定义类型
)
,需要用户
自己显式传递比较规则
(
一般情况下按照函数指针或者仿函数来传递
)
Alloc
:通过空间配置器来申请底层空间,不需要用户传递,除非用户不想使用标准库提供的
空间配置器
注意:在使用
map
时,需要包含头文件。
2.
map
的构造
3. map的迭代器
4. map的容量与元素访问
问题:当key不在map中时,通过operator获取对应value时会发生什么问题?
注意:在元素访问时,有一个与operator[]类似的操作at()(该函数不常用)函数,都是通过 key找到与key对应的value然后返回其引用,不同的是:当key不存在时,operator[]用默认 value与key构造键值对然后插入,返回该默认value,at()函数直接抛异常。
5.
map
中元素的修改
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include <string>
#include <map>
int main()
{
map<string, string> m;
// 向map中插入元素的方式:
// 将键值对<"peach","桃子">插入map中,用pair直接来构造键值对
m.insert(pair<string, string>("peach", "桃子"));
// 将键值对<"peach","桃子">插入map中,用make_pair函数来构造键值对
m.insert(make_pair("banan", "香蕉"));
// 借用operator[]向map中插入元素
// /*
//operator[]的原理是:
// 用<key, T()>构造一个键值对,然后调用insert()函数将该键值对插入到map中
// 如果key已经存在,插入失败,insert函数返回该key所在位置的迭代器
// 如果key不存在,插入成功,insert函数返回新插入元素所在位置的迭代器
// operator[]函数最后将insert返回值键值对中的value返回
//*/
// 将<"apple", "">插入map中,插入成功,返回value的引用,将“苹果”赋值给该引
//用结果,
m["apple"] = "苹果";
// key不存在时抛异常
//m.at("waterme") = "水蜜桃";
cout << m.size() << endl;
// 用迭代器去遍历map中的元素,可以得到一个按照key排序的序列
for (auto& e : m)
cout << e.first << "--->" << e.second << endl;
cout << endl;
// map中的键值对key一定是唯一的,如果key存在将插入失败
auto ret = m.insert(make_pair("peach", "桃色"));
if (ret.second)
cout << "<peach, 桃色>不在map中, 已经插入" << endl;
else
cout << "键值为peach的元素已经存在:" << ret.first->first << "--->"
<< ret.first->second << " 插入失败" << endl;
// 删除key为"apple"的元素
m.erase("apple");
if (1 == m.count("apple"))
cout << "apple还在" << endl;
else
cout << "apple被吃了" << endl;
return 0;
}
【总结】
1. map
中的的元素是键值对
2. map
中的
key
是唯一的,并且不能修改
3.
默认按照小于的方式对
key
进行比较
4. map
中的元素如果用迭代器去遍历,可以得到一个有序的序列
5. map
的底层为平衡搜索树
(
红黑树
)
,查找效率比较高
O(log_2 N)
6.
支持
[]
操作符,
operator[]
中实际进行插入查找。
multiset
multiset的介绍
[
翻译
]
:
1. multiset
是按照特定顺序存储元素的容器,其中元素是可以重复的。
2.
在
multiset
中,元素的
value
也会识别它
(
因为
multiset
中本身存储的就是
<value, value>
组成
的键值对,因此
value
本身就是
key
,
key
就是
value
,类型为
T). multiset
元素的值不能在容器
中进行修改
(
因为元素总是
const
的
)
,但可以从容器中插入或删除。
3.
在内部,
multiset
中的元素总是按照其内部比较规则
(
类型比较
)
所指示的特定严格弱排序准则
进行排序。
4. multiset
容器通过
key
访问单个元素的速度通常比
unordered_multiset
容器慢,但当使用迭
代器遍历时会得到一个有序序列。
5. multiset
底层结构为二叉搜索树
(
红黑树
)
。
注意:
1. multiset
中再底层中存储的是
<value, value>
的键值对
2. mtltiset
的插入接口中只需要插入即可
3.
与set的区别是,multiset中的元素可以重复,set是中value是唯一的
4.
使用迭代器对
multiset
中的元素进行遍历,可以得到有序的序列
5. multiset
中的元素不能修改
6.
在
multiset
中找某个元素,时间复杂度为
O(log_2 N)
7. multiset
的作用:可以对元素进行排序
multiset的使用
此处只简单演示
set
与
multiset
的不同,其他接口接口与
set
相同,可参考
set
。
#include <set>void TestSet (){int array [] = { 2 , 1 , 3 , 9 , 6 , 0 , 5 , 8 , 4 , 7 };// 注意: multiset 在底层实际存储的是 <int, int> 的键值对multiset < int > s ( array , array + sizeof ( array ) / sizeof ( array [ 0 ]));for ( auto & e : s )cout << e << " " ;cout << endl ;return 0 ;}
multimap
multimap的介绍
翻译:
1. Multimaps
是关联式容器,它按照特定的顺序,存储由
key
和
value
映射成的键值对
<key,
value>
,其中多个键值对之间的
key
是可以重复的。
2.
在
multimap
中,通常按照
key
排序和惟一地标识元素,而映射的
value
存储与
key
关联的内
容。
key
和
value
的类型可能不同,通过
multimap
内部的成员类型
value_type
组合在一起,
value_type
是组合
key
和
value
的键值对
:
typedef pair<const Key, T> value_type
;
3.
在内部,
multimap
中的元素总是通过其内部比较对象,按照指定的特定严格弱排序标准对
key
进行排序的。
4. multimap
通过
key
访问单个元素的速度通常比
unordered_multimap
容器慢,但是使用迭代
器直接遍历
multimap
中的元素可以得到关于
key
有序的序列。
5. multimap
在底层用二叉搜索树
(
红黑树
)
来实现。
注意:
multimap
和
map
的唯一不同就是:
map
中的
key
是唯一的,而
multimap
中
key
是可以
重复的
。
multimap的使用
multimap
中的接口可以参考
map
,功能都是类似的。
注意:
1. multimap
中的
key
是可以重复的。
2. multimap
中的元素默认将
key
按照小于来比较。
3. multimap
中没有重载
operator[]
操作。
(
思考下为什么?因为在 multimap 中,由于键可以重复,使用 operator[] 就会变得复杂,因为同一个键可能对应多个值。如果要实现类似的功能,需要考虑如何处理这种多值的情况)。
4.
使用时与
map
包含的头文件相同。
底层结构
前面对
map/multimap/set/multiset
进行了简单的介绍,在其文档介绍中发现,这几个容器有个
共同点是:
其底层都是按照二叉搜索树来实现的
,但是二叉搜索树有其自身的缺陷,假如往树中
插入的元素有序或者接近有序,二叉搜索树就会退化成单支树,时间复杂度会退化成
O(N)
,因此
map
、
set
等关联式容器的底层结构是对二叉树进行了平衡处理,即采用平衡树来实现。