在初阶阶段,我们已经接触过STL中的部分容器,比如:vector、list、deque、forward_list(C++11)等,这些容器统称为序列式容器,因为其底层为线性序列的数据结构,里面存储的是元素本身,并且插入数据的位置是无所谓的。那什么是关联式容器?它与序列式容器有什么区别?
我们即将要学的map,set就是一种树形结构的关联式容器,也是用来存储数据的,其里面存储的是
用来表示具有一一对应关系的一种结构,该结构中一般只包含两个成员变量key和value,key代表键值,value表示与key对应的信息。比如:现在要建立一个英汉互译的字典,那该字典中必然有英文单词与其对应的中文含义,而且,英文单词与其中文含义是一一对应的关系,即通过该应该单词,在词典中就可以找到与其对应的中文含义。
键值对是一个pair类模板。,里面两个成员变量first,second。两个成员函数,一个无参构造,一个有参构造。关于它的使用我们放在map在细看,map是如何对其使用的。
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)
{}
};
set是一个K模型平衡搜索二叉树(AVL树)。
set文档介绍
先看看它模板参数
T: set中存放元素的类型,其实换成K更合适一些,不过也没什么影响,实际在底层存储
Compare:set中元素默认按照小于来比较。less< T> 是一个仿函数,在List模拟实现详细说过,这里不再细说。
Alloc:set中元素空间的管理方式,使用STL提供的空间配置器管理(C++学的差不多细说)。
函数声明 | 功能介绍 |
---|---|
set (const Compare& comp = Compare(), const Allocator& = Allocator() ); | 构造空的set |
set (InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator() ); | 用[first, last)区间中的元素构造set |
set (const set& x); | set的拷贝构造 |
函数声明 | 功能介绍 |
---|---|
iterator begin() | 返回set中起始位置元素的迭代器 |
iterator end() | 返回set中最后一个元素后面的迭代器 |
const_iterator cbegin() const | 返回set中起始位置元素的const迭代器 |
const_iterator cend() const | 返回set中最后一个元素后面的const迭代器 |
reverse_iterator rbegin() | 返回set第一个元素的反向迭代器,即end |
reverse_iterator rend() | 返回set最后一个元素下一个位置的反向迭代器,即rbegin |
const_reverse_iterator crbegin() const | 返回set第一个元素的反向const迭代器,即cend |
const_reverse_iterator crend() const | 返回set最后一个元素下一个位置的反向const迭代器,即crbegin |
关于这个set的迭代器,建议还是先把list的迭代器学好,才能更好的理解它,因为它也不像vector那样的原生指针。它的迭代器还是封装在加上运算符重载实现的。当然也比list的更加难一些,后面模拟实现再说。
函数声明 | 功能介绍 |
---|---|
bool empty ( ) const | 检测set是否为空,空返回true,否则返回true |
size_type size() const | 返回set中有效元素的个数 |
函数声明 | 功能介绍 |
---|---|
pair |
在set中插入元素x,实际插入的是 |
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& x); | 交换set中的元素 |
void clear ( ) | 将set中的元素清空 |
iterator find ( const key_type& x ) const | 返回set中值为x的元素的位置 |
size_type count ( const key_type& x ) const | 返回set中值为x的元素的个数 |
set,multiset,map,multimap的接口差不多,后面的就不在一一介绍,接下来介绍这些容器使用注意事项。
int main()
{
set<int> st;
st.insert(1);
st.insert(5);
st.insert(2);
st.insert(6);
st.insert(4);
st.insert(1);
set<int>::iterator it = st.begin();
while (it != st.end())
{
cout << *it << " ";
}
cout << endl;
return 0;
}
set底层是一颗平衡搜索二叉树,但是它提供的迭代器使用和以前学过的容器一模一样,所以说它的迭代器和list一样是封装+运算符重载,不过更难一些。
看看它的打印结果。
插入的不是有序的,迭代器去走是有序的,证明它走的是中序。并且我插入了6个值,有一个相同的值没给打印,就相当于去重了。
如果以后想排序并且去重,可以使用set,更快一些。
set:排序+去重。
int main()
{
set<int> st;
st.insert(1);
st.insert(5);
st.insert(2);
st.insert(6);
st.insert(4);
st.insert(1);
set<int>::iterator it = st.begin();
while (it != st.end())
{
cout << *it << " ";
++it;
}
cout << endl;
//范围for对set能不能使用?
for (auto e : st)
{
cout << e << " ";
}
cout << endl;
return 0;
}
当然是可以的,以前说过,范围for底层用的还是迭代器。所以以后想代码少些一点可以使用范围for
int main()
{
set<int> st;
st.insert(1);
st.insert(5);
st.insert(2);
st.insert(6);
st.insert(4);
st.insert(1);
set<int>::iterator it = st.begin();
while (it != st.end())
{
cout << *it << " ";
++it;
}
cout << endl;
for (auto e : st)
{
cout << e << " ";
}
cout << endl;
//使用auto自动识别类型更简单一些
//set::iterator pos = st.find(4);
//有两个find,一个是set类模板提供的,另一个是算法库提供的
//请问那个速度更快一些?
auto pos=st.find(4);
auto pos = find(st.begin(), st.end(), 4);
if (pos != st.end())
{
st.erase(pos);
}
return 0;
}
注意到算法库里面的find是暴力查找,时间复杂度O(N),而set是一个平衡搜索叉树树,时间复杂度是O(log2N)
set中有一个count函数,用来统计相同的值有几个。并且返回个数。
int main()
{
set<int> st;
st.insert(1);
st.insert(5);
st.insert(2);
st.insert(6);
st.insert(4);
st.insert(1);
set<int>::iterator it = st.begin();
while (it != st.end())
{
cout << *it << " ";
++it;
}
cout << endl;
set<int>::iterator pos = st.find(4);
//auto pos = find(st.begin(), st.end(), 4);
if (pos != st.end())
{
st.erase(pos);
}
if (st.count(5))
{
}
return 0;
}
用这个函数也能帮我们判断这个值在不在这个树里,返回值要不是1要不是0,那这个函数有啥用啊。
确实这个函数对set没啥用,但对multiset有用
接下来我们说一说multiset
multi有多重的意思。也就是说multiset允许插入相同的值。
那插入相同的值放哪里呢?
multiset的接口和set是一模一样的。不再详细介绍。
int main()
{
multiset<int> mst;
mst.insert(1);
mst.insert(5);
mst.insert(2);
mst.insert(6);
mst.insert(4);
mst.insert(1);
mst.insert(5);
mst.insert(3);
mst.insert(2);
mst.insert(8);
mst.insert(9);
multiset<int>::iterator it = mst.begin();
while (it != mst.end())
{
cout << *it << " ";
++it;
}
cout << endl;
}
迭代器走也是有序的。以后要想给数据排个序可以直接用这个。
multiset:排序
那这里就有一个问题了,有相同的元素,那find找的是那个元素?
int main()
{
multiset<int> mst;
mst.insert(1);
mst.insert(5);
mst.insert(2);
mst.insert(6);
mst.insert(4);
mst.insert(1);
mst.insert(5);
mst.insert(3);
mst.insert(2);
mst.insert(8);
mst.insert(9);
multiset<int>::iterator it = mst.begin();
while (it != mst.end())
{
cout << *it << " ";
++it;
}
cout << endl;
auto pos=mst.find(1);
if (pos != mst.end())
{
mst.erase(pos);
}
}
multiset允许插入相同的值,因此就可以用count来统计相同的值有多少个。
int main()
{
multiset<int> mst;
mst.insert(1);
mst.insert(5);
mst.insert(2);
mst.insert(6);
mst.insert(4);
mst.insert(1);
mst.insert(5);
mst.insert(3);
mst.insert(2);
mst.insert(8);
mst.insert(9);
multiset<int>::iterator it = mst.begin();
while (it != mst.end())
{
cout << *it << " ";
++it;
}
cout << endl;
auto pos=mst.find(1);
if (pos != mst.end())
{
mst.erase(pos);
}
for (auto e : mst)
{
cout << e << " ";
}
cout << endl;
cout << mst.count(5) << endl;
}
set和multiset都有这三个接口,以前我们也没学过,这里说一下,但是用的很少。
根据下面一段来说一说。
int main()
{
std::multiset<int> mymultiset;
std::multiset<int>::iterator itlow, itup;
for (int i = 1; i < 8; i++) mymultiset.insert(i * 10); // 10 20 30 40 50 60 70
itlow = mymultiset.lower_bound(30);
itup = mymultiset.upper_bound(40);
mymultiset.erase(itlow, itup); // 10 20 50 60 70
std::cout << "mymultiset contains:";
for (std::multiset<int>::iterator it = mymultiset.begin(); it != mymultiset.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n';
return 0;
}
上面就是删掉一段区间。
lower_bound(30);返回大于等于这个值的边界
upper_bound(40);返回大于这个值的边界
所以说这两个接口是为了方便或者左闭右开的区间的。
equal_range(30);是获得这个值的边界。
map是一个KV模型的平衡二叉搜索树/红黑树。
key: 键值对中key的类型
T: 键值对中value的类型
Compare: 比较器的类型,map中的元素是按照key来比较的,缺省情况下按照小于来比较,一般情况下(内置类型元素)该参数不需要传递,如果无法比较时(自定义类型),需要用户自己显式传递比较规则(一般情况下按照函数指针或者仿函数来传递)
Alloc:通过空间配置器来申请底层空间,不需要用户传递,除非用户不想使用标准库提供的空间配置器
map的接口和set几乎完全一样。不过多了下面两个接口下面再解释。
在上面说要建立一个英汉互译的字典,那该字典中必然有英文单词与其对应的中文含义,而且,英文单词与其中文含义是一一对应的关系,即通过该应该单词,在词典中就可以找到与其对应的中文含义。这里我们就可以用map来实现。
在二叉搜索树,我们也写了KV模型的二叉搜索树,不过K和V是分开的。也可以实现上面功能。
而在map中成员类型就是最前面说过的pair类,
为什么map要把K,V放在pair,而不是分开放呢?
下面通过一段代码说明
int main()
{
map<string, string> mp;
//这里插入的是pair的匿名对象,不过写着太麻烦了
mp.insert(pair<string, string>("left", "左边"));
mp.insert(pair<string, string>("right", "右边"));
//也可以使用下面这种简单的方式
mp.insert(make_pair("sort", "排序"));
return 0;
}
make_pair是一个函数模板,这个函数的返回值就是pair匿名对象。
int main()
{
map<string, string> mp;
mp.insert(pair<string, string>("left", "左边"));
mp.insert(pair<string, string>("right", "右边"));
mp.insert(make_pair("sort", "排序"));
mp.insert(make_pair("string", "字符串"));
map<string, string>::iterator it = mp.begin();
while (it != mp.end())
{
cout << *it << endl;//这样写也有问题,拿不到数据
}
return 0;
}
从这里就可以看出,为什么map把K,V放在pair里,这里返回的是一个结构可以返回多个值,不然就只能返回一个K或V的值,
那上面代码错误是什么原因呢?
原因在于*it返回是一个pair自定义对象。而流插入对于自定义对象是没有重载的,不像就内置类型有对应的重载函数。
int main()
{
map<string, string> mp;
mp.insert(pair<string, string>("left", "左边"));
mp.insert(pair<string, string>("right", "右边"));
mp.insert(make_pair("sort", "排序"));
mp.insert(make_pair("string", "字符串"));
map<string, string>::iterator it = mp.begin();
while (it != mp.end())
{
//*it返回的是这个对象
cout << (*it).first<<":" <<(*it).second<< endl;
//it->返回的是这个对象指针,这里实际是it.operator->()->first
//这里少了一个->,是编译器帮我们自动加了
cout << it->first << ":" << it->second << endl;
++it;
}
return 0;
}
当然为了方便我们还是可以使用范围for
for (auto& diet : mp)
{
cout << diet.first << ":" << diet.second << endl;
}
在二叉搜索树写了一段代码,统计水果的个数,今天学了map可以怎么统计呢?
// 统计水果出现的次数
string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
"苹果", "香蕉", "苹果", "香蕉" };
按照以前的思维,先找水果在不在,不在就插入个数+1,在就个数+1,最终统计出水果个数
int main()
{
// 统计水果出现的次数
string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
"苹果", "香蕉", "苹果", "香蕉" };
map<string,int> kv;
for (auto& str : arr)
{
auto it = kv.find(str);
if (it == kv.end())
{
kv.insert(make_pair(str, 1));
}
else
{
it->second++;
}
}
for (auto& it : kv)
{
cout << it.first << ":" << it.second << endl;
}
return 0;
}
int main()
{
// 统计水果出现的次数
string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
"苹果", "香蕉", "苹果", "香蕉" };
map<string,int> kv;
for (auto& str : arr)
{
kv[str]++;
}
for (auto& it : kv)
{
cout << it.first << ":" << it.second << endl;
}
return 0;
}
也能得到刚才的结果。
现在来正式介绍[ ]接口。
看到这里是不是有点头皮发麻,写的太麻烦了,但是经过分析可以找到它的重点,是一个insert接口。
insert返回值是一个pair,我们当初写二叉搜索树的时候,insert返回值写的是一个bool类型来确定是否插入成功。现在这个insert返回pair意思是什么呢?经过文档得知。
返回pair,插入成功时iteraotr指向这个最新结点,并且bool类型是true,插入失败(插入相同的key)iterator指向相同结点的指向,并且bool类型是false。
因此上面的函数就可以转换成
map的[ ]接口有三种功能
1.插入
2.修改
3.查找
int main()
{
map<string, string> diet;
diet.insert(pair<string, string>("right", "右边"));
diet.insert(make_pair("sort", "排序"));
diet.insert(make_pair("string", "字符串"));
diet["left"];//插入
return 0;
}
这样插入有没有问题?
没有的,这里相当于是匿名构造,对于内置类型也没有问题,假设int,那value就是默认的0。
int main()
{
map<string, string> diet;
diet.insert(pair<string, string>("right", "右边"));
diet.insert(make_pair("sort", "排序"));
diet.insert(make_pair("string", "字符串"));
diet["left"];//插入
diet["left"] = "左边";//修改
diet["iterator"] = "迭代器";//插入+修改
cout << diet["left"] << endl;//查找
for (auto& diet1 : diet)
{
cout << diet1.first << ":" << diet1.second << endl;
}
return 0;
}
如果查找按照[ ]的方法去查,一定要小心,一定要确定key在才能这样查,否则就是插入了。
也是允许插入相同的key值。
int main()
{
multimap<string, string> diet;
diet.insert(make_pair("left", "左边"));
diet.insert(make_pair("left", "剩余"));
diet.insert(make_pair("right", "右边"));
diet.insert(make_pair("sort", "排序"));
for (auto& diet1 : diet)
{
cout << diet1.first << ":" << diet1.second << endl;
}
return 0;
}
注意multimap是没有[ ]接口的。
这是因为,map是一对一的关系,而multimap是一对多的关系,如果有[ ],那这个[ ]的返回值返回的是多的中哪一个合适呢?
并且find找的也是中序的第一个。也有count统计相同的值有多少个。
虽然是四个不同的类模板,但是它们的接口几乎一样。接口介绍就到这里。
写道题感受一下把
这里介绍一个比较算法
以后遇到找并集,差集就可以用这个思路。
解题步骤:
先排序+去重
1.相等就是交集,同时++
2.不相等,小的++
有一个结束了就结束了
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
//去重
set<int> s1(nums1.begin(),nums1.end());
set<int> s2(nums2.begin(),nums2.end());
vector<int> ret;
//排序
auto it1=s1.begin();
auto it2=s2.begin();
//比较
while(it1 != s1.end() && it2 != s2.end())
{
if(*it1 == *it2)
{
ret.push_back(*it1);
++it1;
++it2;
}
else if(*it1 < *it2)
{
++it1;
}
else
{
++it2;
}
}
return ret;
}
};