目录
一、关联式容器和键值对
1.关联式容器
前面的STL的容器，如vector、list、deque等都是序列式容器，因为
（1）底层的数据结构是线性的
（2）存储的是元素本身
（3）数据和数据之间没有关联
关联式容器也是用来存储数据的， 不过里面存储的是<key, value>键值对，数据检索时，效率比序列式容器高。STL有两种关联式容器：树形结构和哈希结构。树形结构的关联式容器有4种：set、map 、multiset、mapltimap，它们的底层都是平衡搜索树（红黑树）。
2.键值对
用来表示具有一一对应关系的结构，该结构中一般只包含两个成员变量key和value，key代表键值，value表示与key对应的信息。
比如：英汉互译字典中必然有英文单词与其对应的中文含义，而且，英文单词与其中文含义一一对应，即通过该英文单词，在词典中就可以找到与其对应的中文含义。
二、set
1.set特点
set是按照一定次序存储元素的容器，它有以下特点：
（1）在set中，用value标识元素(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。
（2）在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。
（3）set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭代。
（4）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中查找某个元素，时间复杂度为：
（7）set中的元素不允许修改，因为底层的二叉搜索树是有序的，如果修改了元素，会破坏有序的性质
（8）set中的底层使用二叉搜索树(红黑树)来实现
2.set类
（1） set类对象构造
template < class T, // set::key_type/value_type 元素的类型
class Compare = less<T>, // set::key_compare/value_compare 比较方式，默认小于
class Alloc = allocator<T> // set::allocator_type 使用STL提供的空间配置器管理方式
> class set;
//构造set
explicit set (const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());
template <class InputIterator>
//使用迭代器区间构造set
set (InputIterator first, InputIterator last,
const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());
//拷贝构造set
set (const set& x); 创建set对象：
#include<iostream>
using namespace std;
int main()
{
set<int> s;//创建一个set对象s
//向s中插入元素
set<int> s1(s.begin(),s.end());//用s的区间构造s1
set<int> s2(s1);//用s1拷贝构造s2
return 0;
}（2）insert插入
s1.insert(1);
s1.insert(2);
s1.insert(3);
s1.insert(1);
s1.insert(4);
s1.insert(2);（3）set遍历
①迭代器遍历：
正向迭代器遍历：
iterator begin();//正向迭代器
const_iterator begin() const;//正向const迭代器 //set 排序+去重
//遍历1：
set<int>::iterator it= s.begin();
while (it != s.end())
{
cout << *it << " ";
it++;
}
cout << endl;
// 1 2 3 4 -- 排序+去重 不允许冗余 反向迭代器遍历：
reverse_iterator rbegin();//反向迭代器
const_reverse_iterator rbegin() const;//反向const迭代器 set<int>::reverse_iterator it= s.rbegin();
while (it != s.rend())
{
cout << *it << " ";
it++;
}
cout << endl;
// 4 3 2 1 -- 排序+去重 不允许冗余 ②范围for遍历
set<string> s1;
s1.insert("spring");
s1.insert("summer");
s1.insert("autumn");
s1.insert("winter");
for (const auto& e : s1)
//如果不加引用，s1中的每个元素都是深拷贝，每次都要调用拷贝构造，代价大
{
cout << e << " ";
}
cout << endl;
// autum spring summer winter（4）find查找
iterator find (const value_type& val) const;
//找到了就返回这个元素的迭代器，否则返回end如：
int x;
while (cin >> x)
{
//auto ret = s1.find(x);
//if (ret != s1.end())
// cout << "在" << endl;
//else
// cout << "不在" << endl;
if (s1.count(x))// 返回元素个数
cout << "在" << endl;
else
cout << "不在" << endl;
}（5）erase删除
void erase (iterator position);//删除指定位置元素
size_type erase (const value_type& val);//从set中删除指定的值
void erase (iterator first, iterator last);//删除指定区间①删除指定位置元素：
删除元素5：
set<int> s;
s.insert(6);
s.insert(2);
s.insert(5);
s.insert(8);
s.insert(5);
set<int>::iterator ret = s.find(5);
if (ret != s.end())
{
s.erase(ret);
}
for (auto e : s)
{
cout << e << " ";
}
cout << endl;
// 2 6 8②删除指定值元素
删除值为8的元素：
set<int> s;
s.insert(6);
s.insert(2);
s.insert(5);
s.insert(8);
s.insert(5);
//删除值为8的元素
s.erase(8);
for (auto e : s)
{
cout << e << " ";
}
cout << endl;
// 2 5 6③删除指定区间
删除5之前的元素：
set<int> s;
s.insert(6);
s.insert(2);
s.insert(5);
s.insert(8);
s.insert(5);
//删除5之前的元素
set<int>::iterator ret = s.find(5);
s.erase(s.begin(), ret);
for (auto e : s)
{
cout << e << " ";
}
cout << endl;
// 5 6 8（6）计数count( )
计算set中值为val的元素的个数：
size_type count (const value_type& val) const;
//计算set中值为val的元素的个数由于set中的元素不重复，因此，set的count的计算结果≤1。
计算s中值为5的元素的个数：
set<int> s;
s.insert(6);
s.insert(2);
s.insert(5);
s.insert(8);
s.insert(5);
cout << s.count(5) << endl; // 1（7）交换swap( )
交换*this和x的根
void swap (set& x); set<int> s;
s.insert(6);
s.insert(2);
s.insert(5);
s.insert(8);
s.insert(5);
cout << "交换前s: ";
for (auto e : s)
{
cout << e << " ";
}
cout << endl;
// 2 5 6 8
set<int> s1;
s1.insert(12);
s1.insert(18);
s1.insert(16);
s1.insert(11);
s1.insert(13);
cout << "交换前s1: ";
for (auto e : s1)
{
cout << e << " ";
}
cout << endl;
// 11 12 13 16 18
//s.swap(s1);
swap(s, s1);
cout << "交换后s: ";
for (auto e : s)
{
cout << e << " ";
}
cout << endl;
// 11 12 13 16 18
cout << "交换后s1: ";
for (auto e : s1)
{
cout << e << " ";
}
cout << endl;
// 2 5 6 8注意：如果将 s.swap(s1); 写成 swap(s,s1); 那么就会从交换根变成深拷贝。
（8）判空empty( )
判断set是否为空：
bool empty() const;判断s是否为空：
cout << s.empty() << endl; // 0（9）求set的元素个数size( )
求set的元素个数：
size_type size() const;求s的元素个数：
cout << s.size() << endl; // 4（10）清空所有元素clear( )
清空set中的元素：
void clear();清空s中的所有元素：
s.clear();
for (auto e : s)
{
cout << e << " ";
}
cout << endl;三、map
1.map特点
（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通常被实现为平衡二叉搜索树(红黑树)。
2.map类
（1）map类的构造
template < class Key, // map::key_type,Key的类型
class T, // map::mapped_type,value的类型
class Compare = less<Key>, // map::key_compare，比较器类型，默认小于，自定义类型需写函数指针或仿函数
class Alloc = allocator<pair<const Key,T> > // map::allocator_type 空间配置器
> class map;
//构造map
explicit map (const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());
使用迭代器区间构造map
template <class InputIterator>
map (InputIterator first, InputIterator last,
const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());
//拷贝构造map
map (const map& x);创建map对象：
#include<iostream>
#include<map>
using namespace std;
int main()
{
map<string, int> m;//创建一个map对象m
//向m中插入pair
map<string, int> m1(m.begin(), m.end);//用m的区间构造m1
map<string, int> m2(m1);//用m1拷贝构造m2
return 0;
}（2）插入insert( )
pair<iterator,bool> insert (const value_type& val);
//当val的first已存在时返回值pair的second为false，否则返回pair的second为true
iterator insert (iterator position, const value_type& val);
//在map的指定位置插入pair
template <class InputIterator>
void insert (InputIterator first, InputIterator last);
//在map中插入一段迭代器区间①插入pair，由于此时map中没有足球，因此pair的second为true：
bool b = m.insert(pair<string, int>("足球", 2)).second;
cout << b << endl;
m.insert (pair<string, int>("篮球", 6));
m.insert (pair<string, int>("羽毛球", 3));
m.insert (pair<string, int>("排球", 1));make_pair对pair进行了包装，构造了pair对象：
template <class T1,class T2>
pair<T1,T2> make_pair (T1 x, T2 y)
{
return ( pair<T1,T2>(x,y) );
}因此，在项目中，不展开命名空间时，都要指定std，make_pair要比pair写起来更简洁一些，对比以下两种写法：
m.insert(std::pair<std::string, int>("网球", 7));
m.insert(std::make_pair("网球", 7));明显make_pair的写法更简洁。
②在map的指定位置插入pair
map<string, int> m;
//向m中插入pair
m.insert (pair<string, int>("足球", 2));
m.insert (pair<string, int>("篮球", 6));
m.insert (pair<string, int>("羽毛球", 3));
m.insert (pair<string, int>("排球", 1));
//在m开始插入乒乓球
map<string, int>:: iterator it = m.begin();
m.insert(it, pair<string, int>("乒乓球",5));监视： 
③在map中插入一段迭代器区间
向m1中插入m从第二个位置开始到结束位置的区间：
map<string, int> m1;
m1.insert(++m.begin(), m.end());监视：
这里少了篮球，说明m的第一个pair是<"篮球"，6>。
（3）map遍历
auto在变量被定义并初始化之后编译器才能根据初始化表达式来推导auto的实际类型，所以在定义map对象时，不能使用auto关键字，在变量被定义并初始化之后可以使用auto关键字：
map<string, string> dict;
//dict.insert(pair<string, string>("sort", "排序"));
dict.insert(make_pair("sort", "排序")); // 自动推导类型
dict.insert(make_pair("string", "字符串"));
dict.insert(make_pair("count", "计数"));
dict.insert(make_pair("string", "字符串"));// 插入失败，已有key，即string
string str;
map<string, string>::iterator dit = dict.begin();
while (dit != dict.end())
{
//cout << *dit << " ";
// 不支持返回一个值，返回的是一个结构，需要返回的两个值
//cout << (*dit).first << ":" << (*dit).second << endl;
cout << dit->first << ":" << dit->second << endl;
++dit;
}
cout << endl;
注意： 同set一样，map的key不允许修改, 但是map的value可以修改
map也可以用来统计次数，比如找出大家最喜欢的水果，统计技术有3种方式：
第一种方式：找到就增加次数，否则就插入
string arr[] = { "西瓜","西瓜","苹果","香蕉","葡萄","西瓜","香蕉", "苹果" };
map<string, int> countMap;
for (auto& e : arr)
{
auto ret = countMap.find(e);
if (ret == countMap.end())
countMap.insert(make_pair(e, 1));
else
ret->second++;
}
for (auto& kv : countMap)
{
cout << kv.first << ":" << kv.second << endl;
}
第二种方式：借助计数排序思想，使用operator[ ]运算符重载获取value
mapped_type& operator[] (const key_type& k);//返回k对应的value的引用返回：
(*((this->insert(make_pair(k,mapped_type()))).first)).second即：
V& operatorp[](const K& key)
{
pair<iterator, bool> ret = insert(make_pair(key, mapped_type()));
return ret.first->second;
}operator[ ]的本质就是插入：
①如果k不在map中，先插入<k,V( )>，返回节点中V对象的引用
②如果k已经在map中，返回k所在节点中对应V对象的引用
string arr[] = { "西瓜","西瓜","苹果","香蕉","葡萄","西瓜","香蕉", "苹果" };
map<string, int> countMap;
for (auto& e : arr)
{
countMap[e]++;
//等价于countMap.operator[](e),会调用mapped type()的默认构造函数构造一个匿名对象。其中e是key,++的是key对应的value，即返回值
}
for (auto& kv : countMap)
{
cout << kv.first << ":" << kv.second << endl;
}
这三种方式中，operator[ ]最简洁，更好使用。
计数结束后，排序有2种方式：
第一种排序：用sort排序
可以使用sort进行排序，先包含sort的头文件:
#include<algorithm>vector里面如果要存pair，得把每个pair拿出来拷贝，再插入到vector中，而且string是深拷贝，代价大。
sort要排序，必须支持整数比较大小，传的是迭代器，迭代器指向的数据必须要能比较大小，v里面存的是pair，需要重载pair的比较大小。 sort的第3个参数是compare，要传对象，用实际对象推compare的类型，可以用仿函数比较，给sort的第3个参数传个匿名对象
sort的第3个参数是Compare比较方式，默认是按小于比较的，要找排名前面的球类，必须要传入大于的比较方式，就需要重新写仿函数：
template <class RandomAccessIterator, class Compare>
void sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);大于的比较方式的仿函数：
struct MapItCompare
{
bool operator()(map<string, int>::iterator x, map<string, int>::iterator y)
{
return x->second > y->second;
}
};
扫一扫
2347
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
