关联容器
介绍
关联容器是对容器概念的另一个改进。关联容器将键关联在一起，并使用键来查找值。对于关联容器，表达式X::key_type指出键的类型(X表示容器）。
- 优点在于提供对元素的快速访问。
- 与序列容器相似，关联容器也允许插入新元素，但不能指定元素的插入位置。原因：关联容器通常有用确定数据放置位置的算，便能快速检索信息。
- 关联容器通常是使用某种树实现的。树是一种数据结构其根节点链接到一个或两个节点，而这些节点又链接到一个或两个节点，从而形成分支结构。像链表一样，节点使得添加或删除数据项比较简单，但树的查询速度更快。
- STL提供4种关联容器：set，multiset,map和multimap（前两种头文件：set,multiset.h;后两种：map，multimap.h）
set容器
- 值类型与键相同，键是唯一的，意味着集合中不会有多个相同的键。值就是键。
- 所有元素都会根据元素的键值自动被排序
- set的元素即是键值又是实值。
- set容器的键值 不允许相同。
- set容器提供的是只读迭代器（不允许用户修改元素的内容）
set构造和赋值
函数原型：
- set st; //默认构造函数：
- set(const set &st); //拷贝构造函数
- set& operator=(const set &st); //重载等号操作符（赋值）
#include <iostream>
#include<set>
using namespace std;
void printSet(set<int>& s)
{
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
set<int> s1;
s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(40);
printSet(s1);
//拷贝构造
set<int>s2(s1);
printSet(s2);
//赋值
set<int>s3;
s3 = s2;
printSet(s3);
}
int main()
{
test01();
return 0;
}
总结：
set容器插入数据时用insert
set容器插入数据的数据会自动排序
set大小和交换
函数原型：
- size(); //返回容器中元素的数目
- empty(); //判断容器是否为空
- swap(st); //交换两个集合容器
#include <iostream>
#include<set>
using namespace std;
void printSet(set<int>& s)
{
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
//大小
void test01()
{
set<int> s1;
s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(40);
if (s1.empty())
{
cout << "s1为空" << endl;
}
else
{
cout << "s1不为空" << endl;
cout << "s1的大小为： " << s1.size() << endl;
}
}
void test02()
{
set<int> s1;
s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(40);
set<int> s2;
s2.insert(100);
s2.insert(300);
s2.insert(200);
s2.insert(400);
cout << "交换前" << endl;
printSet(s1);
printSet(s2);
cout << endl;
cout << "交换后" << endl;
s1.swap(s2);
printSet(s1);
printSet(s2);
}
int main()
{
//test01();
test02();
return 0;
}
总结：
统计大小 — size
判断是否为空 — empty
交换容器 — swap
set插入和删除
函数原型：
- insert(elem);//在容器中插入元素
- clear(); //清除所有元素
- erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
- erase(beg, end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
- erase(elem); //删除容器中值为elem的元素。
#include <iostream>
#include<set>
#include<algorithm>
using namespace std;
void printSet(set<int>& s)
{
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
set<int> s1;
s1.insert(30);
s1.insert(40);
s1.insert(20);
s1.insert(50);
s1.insert(10);
for_each(s1.begin(), s1.end(), [](int val)
{
cout << val << " ";
});
cout << endl;//10,20,30,40,50
//set容器提供的是只读迭代器const_iterator 3
//用户不可以修改set容器的元素
set<int>::const_iterator it = s1.begin();
//*it=100;//err
cout << "size=" << s1.size() << endl;
//删除起始位置的元素
s1.erase(s1.begin());
for_each(s1.begin(), s1.end(), [](int val)
{
cout << val << " ";
});//20 30 40 50
cout << endl;
//根据元素删除
s1.erase(40);
for_each(s1.begin(), s1.end(), [](int val)
{
cout << val << " ";
});//20 30 50
}
int main()
{
test01();
return 0;
}
set容器的查找
函数原型：
- find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
- count(key);//查找键key的元素个数
#include <iostream>
#include<set>
#include<algorithm>
using namespace std;
void printSet(set<int>& s)
{
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
set<int> s1;
s1.insert(30);
s1.insert(40);
s1.insert(20);
s1.insert(50);
s1.insert(10);
//find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；
//若不存在，返回set.end();
set<int>::const_iterator ret;
ret = s1.find(20);
if (ret == s1.end())
{
cout << "没有找到" << endl;
}
else
{
cout << "找到" << *ret << endl;
}
//count(key);//查找键key的元素个数
//set容器的键值 是不重复的 那么count(key)只能是1或0
cout << s1.count(20) << endl;//1
cout << s1.count(200) << endl;//0
}
int main()
{
test01();
return 0;
}
、set容器的lower_bound和upper_bound
函数原型：
- lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
- upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
- equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器
~~#include <iostream>
#include<set>
#include<algorithm>
using namespace std;
void printSet(set<int>& s)
{
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
set<int> s;
//set容器自动根据键值排序
s.insert(30);
s.insert(10);
s.insert(20);
s.insert(50);
s.insert(40);
//下限:lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
set<int>::const_iterator lower_ret;
lower_ret = s.lower_bound(30);
if(lower_ret == s.end())
{
cout<<"没有找到30的下限"<<endl;
}
else
{
cout << "找到30的下限:" << *lower_ret << endl;
}
//upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器
set<int>::const_iterator up_ret;
up_ret = s.upper_bound(30);
if(up_ret == s.end())
{
cout<<"没有找到30的上限"<<endl;
}
else
{
cout<<"找到30的上限:"<<*up_ret<<endl;
}
//equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器
//equal_range 返回的是对组
//first 对组中第一个值 second对组中第二个值
pair<set<int>::const_iterator , set<int>::const_iterator> pair_ret;
pair_ret = s.equal_range(30);
//下限lower_bound
if(pair_ret.first == s.end())
{
cout<<"下限未找到"<<endl;
}
else
{
cout<<"下限找到:"<< *(pair_ret.first) <<endl;
}
//上限upper_bound
if(pair_ret.second == s.end())
{
cout<<"上限未找到"<<endl;
}
else
{
cout<<"上限找到:"<< *(pair_ret.second) <<endl;
}
}
int main()
{
test01();
return 0;
}~~
练习：
#include <iostream>
#include<set>
#include<string>
#include<iterator>
#include<algorithm>
using namespace std;
int main()
{
const int N=6;
string s1[N]={"buffon","thinkers","for","heavy","can","for"};
string s2[N]={"metal","any","food","elegant","deliver","for"};
set<string> A(s1,s1+N);//使用数组中的范围初始化集合
set<string> B(s2,s2+N);
ostream_iterator<string,char> out(cout," ");
cout<<"Set A:";
copy(A.begin(),A.end(),out);
cout<<endl;
cout<<"Set B:";
copy(B.begin(),B.end(),out);
cout<<endl;
cout<<"Union of A and B:\n";
set_union(A.begin(),A.end(),B.begin(),B.end(),out);
cout<<endl;
cout<<"Intersection of and B:\n";
set_intersection(A.begin(),A.end(),B.begin(),B.end(),out);//查找交集
cout<<endl;
cout<<"Difference of A and B:\n";
set_difference(A.begin(),A.end(),B.begin(),B.end(),out);//获得两个集合的差
cout<<endl;
set<string> C;
cout<<"Set C:\n";
set_union(A.begin(),A.end(),B.begin(),B.end(),
insert_iterator<set<string> >(C,C.begin()));
copy(C.begin(),C.end(),out);接受5个迭代器参数，前两个：第一个集合区间；下两个：第二个集合区间；最后：输出迭代器，指出将结果复制到什么位置;insert_iterator:创建匿名，将信息复制给C
cout<<endl;
string s3("grungy");
C.insert(s3);
cout<<"Set after insertion:\n";
copy(C.begin(),C.end(),out);
cout<<endl;
cout<<"Showing a range:\n";
copy(C.lower_bound("ghost"),C.upper_bound("spook"),out);
cout<<endl;
return 0;
}
注释·：
1.lower_bound:将键值作为参数并返回一个迭代器，该迭代器指向集合中第一个不小于键参数的成员。
2.upper_bound:将键作为参数，并返回一个迭代器，该迭代器指向集合中第一个大于键得成员。
3.因为排序决定了插入的位置，所以这种类包含只指定要插入的信息，而不指定位置的插入方法：
例：
string s("tennis");
A.insert(s);
B.insert(A.begin(),A.end());
pair对组创建
创建方式：
1.pair<type, type> p ( value1, value2 );
2.pair<type, type> p = make_pair( value1, value2 );
#include <iostream>
#include<set>
#include<string>
using namespace std;
void test01()
{
//第一种
pair<string, int>p1("Tom", 12);
cout << "姓名:" << p1.first << "年龄:" << p1.second << endl;
//第二种(推荐）
pair<string, int>p2 = make_pair("lucy", 16);
cout << "姓名:" << p2.first << "年龄:" << p2.second << endl;
}
int main()
{
test01();
return 0;
}
更改set容器的默认排序规则（推荐使用仿函数）
#include <iostream>
#include<set>
#include<algorithm>
using namespace std;
class MyGreater
{
public:
bool operator()(int val1, int val2)
{
return val1 > val2;
}
};
void test01()
{
//默认从小‐‐>大排
//改成从大‐‐>小排
//set<int,排序规则> s;
set<int,MyGreater> s;
s.insert(30);
s.insert(10);
s.insert(20);
s.insert(50);
s.insert(40);
for_each(s.begin(),s.end(),[](int val){cout<<val<<" ";});
cout<<endl;
}
int main(int argc, char *argv[])
{
test01();
return 0;
}
set容器存放自定义数据的时候 重载<运算符
#include <iostream>
#include<set>
#include<algorithm>
using namespace std;
class Person
{
public:
string name;
int age;
Person(string name, int age)
{
this-> name = name;
this-> age = age;
}
//方法一：重载<运算符 小‐‐>大
bool operator<(const Person& ob)const
{
return this-> age < ob.age;
}
};
void test01()
{
set<Person> s;
s.insert(Person("小明", 19));
s.insert(Person("小法", 18));
s.insert(Person("小华", 21));
s.insert(Person("Tom", 29));
for_each(s.begin(), s.end(), [](Person val) {
cout << "name=" << val.name << ", age=" << val.age << endl;
});
}
int main(int argc, char* argv[])
{
test01();
return 0;
}
set容器存放自定义数据的时候 指定排序规则。
#include <iostream>
#include<set>
#include<algorithm>
using namespace std;
class Person
{
public:
string name;
int age;
Person(string name, int age)
{
this->name =name;
this->age = age;
}
#if 0
//方法一：重载<运算符 小‐‐>大
bool operator<(const Person &ob) const
{
//单纯的告诉编译器 该函数为常函数不会修改成员数据
//常对象 调用 常函数
return this‐>age < ob.age;
}
#endif
};
class myGreaterPerson
{
public:
bool operator()(const Person &ob1, const Person &ob2)
{
return ob1.age > ob2.age;
}
};
void test01()
{
//方法二：指定排序规则
set<Person, myGreaterPerson> s;
s.insert(Person("小明", 19));
s.insert(Person("小法", 18));
s.insert(Person("小华", 21));
s.insert(Person("Tom", 29));
for_each(s.begin(),s.end(),[](Person val){
cout<<"name="<<val.name<<", age="<<val.age<<endl;
});
}
int main(int argc, char *argv[])
{
test01();
return 0;
}
multiset
与set相似，multiset也是可反转的，经过排序的关联容器，但键和值的类型不同，且同一个键可能与多个值相关联。
基本的multimap声明使用模板参数指定键的类型和存储的值类型。例如：下面声明创建一个multimap对象，其中键值类型为int，存储的值类型为string:
multimap<int,string> codes;
第三个模板参数是可选的，指出用于对键进行的比较函数或对象。在默认的情况下，将使用模板less<>(稍后介绍），该模板将键类型作为参数。老式c++实现可能要求显示指定该模板参数。
#include <iostream>
#include<string>
#include<map>
#include<algorithm>
using namespace std;
typedef int KeyType;
typedef pair<const KeyType,string> Pair;
typedef multimap<KeyType,string>MapCode;
int main()
{
MapCode codes;
codes.insert(Pair(415,"San Francisco"));
codes.insert(Pair(510,"Oakland"));
codes.insert(Pair(718,"Brooklyn"));
codes.insert(Pair(718,"Staten Island"));
codes.insert(Pair(415,"San Rafael"));
codes.insert(Pair(510,"Berkeley"));
cout<<"Number of cities with area code 415:"
<<codes.count(415)<<endl;//接受键值作为参数并返回具有该键的元素数目
cout<<"Number of cities with area code 718:"
<<codes.count(718)<<endl;
cout<<"Number of cities with area code 510:"
<<codes.count(510)<<endl;
cout<<"Area Code City\n";
MapCode::iterator it;
for(it=codes.begin();it!=codes.end();it++)
cout<<" "<<(*it).first<<" "
<<(*it).second<<endl;
pair<MapCode::iterator,MapCode::iterator>
range=codes.equal_range(718);//使用c++11自动类型推断功能
cout<<"Cities with area code 718:\n";
for(it=range.first;it!=range.second;it++)
cout<<(*it).second<<endl;
return 0;
}
set和multiset区别
区别：
- set不可以插入重复数据，而multiset可以
- set插入数据的同时会返回插入结果，表示插入是否成功
- multiset不会检测数据，因此可以插入重复数据
#include <iostream>
#include<set>
#include<algorithm>
using namespace std;
int main()
{
set<int> s;
pair<set<int>::iterator,bool> ret=s.insert(10);
if(ret.second)
{
cout<<"第一次插入成功"<<endl;
}
else
{
cout<<"第一次插入失败"<<endl;
}
ret=s.insert(10);
if(ret.second)
{
cout<<"第二次插入成功"<<endl;
}
else
{
cout<<"第二次插入失败"<<endl;
}
//multiset
multiset<int> ms;
ms.insert(10);
ms.insert(10);
for(multiset<int>::iterator it=ms.begin();it!=ms.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
}
map容器
- 值与键的类型不同，键是唯一，每个键只对应一个值。
- map中所有元素都是pair(对组）
- pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值）
- 所有元素都会根据元素的键值自动排序
- map容器的键值唯一 不可变 实值 可变。
map构造和赋值
函数原型：
- map<T1, T2> mp; //map默认构造函数:
- map(const map &mp); //拷贝构造函数
- map& operator=(const map &mp); //重载等号操作符（赋值运算符）
#include <iostream>
#include<map>
using namespace std;
void printMap(map<int,int> &m)
{
for(map<int,int>::iterator it=m.begin();it !=m.end();it++)
{
cout<<"key="<<(*it).first<<",value="<<(*it).second<<endl;
}
}
int main()
{
map<int,int>m;//默认构造
m.insert(pair<int,int>(1,10));
m.insert(pair<int,int>(2,20));
m.insert(pair<int,int>(3,30));
printMap(m);
map<int,int>m2(m);//拷贝构造
printMap(m2);
map<int,int>m3;
m3=m2;//赋值
printMap(m3);
}
总结：map中所有元素都是成对出现，插入数据时候要使用对组
map大小和交换
函数原型：
- size(); //返回容器中元素的数目
- empty(); //判断容器是否为空
- swap(st); //交换两个集合容器
#include <iostream>
#include<map>
using namespace std;
void printMap(map<int,int> &m)
{
for(map<int,int>::iterator it=m.begin();it !=m.end();it++)
{
cout<<"key="<<(*it).first<<",value="<<(*it).second<<endl;
}
cout<<endl;
}
void test01()
{
map<int,int>m;
m.insert(pair<int,int>(1,10));
m.insert(pair<int,int>(2,20));
m.insert(pair<int,int>(3,30));
if(m.empty())
{
cout<<"m为空"<<endl;
}
else
{
cout<<"m不为空"<<endl;
cout<<"m的大小"<<m.size()<<endl;
}
}
//交换
void test02()
{
map<int,int>m;
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 20));
m.insert(pair<int, int>(3, 30));
map<int, int>m2;
m2.insert(pair<int, int>(4, 100));
m2.insert(pair<int, int>(5, 200));
m2.insert(pair<int, int>(6, 300));
cout<<"交换后："<<endl;
printMap(m);
printMap(m2);
cout<<"交换后"<<endl;
m.swap(m2);
printMap(m);
printMap(m2);
}
int main()
{
test01();
test02();
return 0;
}
总结：
- 统计大小 — size
- 判断是否为空 — empty
- 交换容器 — swap
map插入和删除
函数原型：
- insert(elem); //在容器中插入元素
- clear(); //清除所有元素
- erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
- erase(beg, end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
- erase(key); //删除容器中值为key的元素。
#include <iostream>
#include<map>
using namespace std;
void printMap(map<int,string> &m)
{
for(map<int,string>::iterator it=m.begin();it !=m.end();it++)
{
cout<<"key="<<(*it).first<<",value="<<(*it).second<<endl;
}
cout<<endl;
}
void test01()
{
map<int,string> m;
//第一种插入：
m.insert(pair<int,string>(13,"Tom"));
//第二种插入:
m.insert(make_pair(12,"lucy"));
//第三种插入:
m.insert(map<int,string>::value_type(3,"Lihua"));
//第四种
m[10] ="Palu";
//删除
m.erase(m.begin());
printMap(m);
m.erase(3);
printMap(m);
//清空
m.erase(m.begin(),m.end());
m.clear();
printMap(m);
}
int main()
{
test01();
return 0;
}
总结：
- 插入 — insert
- 删除 — erase
- 清空 — clear
- map插入方式很多，推荐第二种
map查找和统计
- find(key); //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
- count(keyElem);//返回容器中key为keyElem的对组个数。对map来说，要么是0，要么是 1。对multimap来说，值可能大于1。
#include <iostream>
#include<map>
using namespace std;
void test01()
{
map<int,int> m;
m.insert(pair<int,int>(1,10));
m.insert(pair<int,int>(2,20));
m.insert(pair<int,int>(3,30));
//查找
map<int,int>::const_iterator pos=m.find(3);
if(pos !=m.end())
{
cout<<"找到key="<<(*pos).first<<"value="<<(*pos).second<<endl;
}
else
{
cout<<"未找到"<<endl;
}
//统计
int num=m.count(3);
cout<<"num="<<num<<endl;
}
int main()
{
test01();
return 0;
}
总结：
- 查找 — find （返回的是迭代器）
- 统计 — count （对于map，结果为0或者1）
map容器排序
利用仿函数：
#include <iostream>
#include<map>
using namespace std;
class MyCompare
{
public:
bool operator ()(int val1,int val2)
{
return val1>val2;
}
};
int main()
{
//默认从小到大,利用仿函数实现从大到小排序
//map<int,int,排序规则>m;
map<int ,int,MyCompare>m;
m.insert(make_pair(1, 10));
m.insert(make_pair(2, 20));
m.insert(make_pair(3, 30));
m.insert(make_pair(4, 40));
m.insert(make_pair(5, 50));
for(map<int,int,MyCompare>::iterator it=m.begin();it!=m.end();it++)
{
cout<<"Key:"<<(*it).first<<"value:"<<(*it).second<<endl;
}
}
map和vector容器配合使用（重要）
#include<iostream>
#include<numeric>//极少算法
#include<stdlib.h>
#include<time.h>
#include<algorithm>
#include<map>
#include<vector>
using namespace std;
int main()
{
//设置随机种子
srand(time(NULL));
map<int,string> m;
m.insert(make_pair(1,"小明"));
m.insert(make_pair(2,"小华"));
m.insert(make_pair(3,"Tom"));
m.insert(make_pair(4,"lucy"));
//使用vector存放编号
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
//随机抽签(洗牌) 打乱容器的元素顺序
random_shuffle(v.begin(),v.end());
//随机出场
for_each(v.begin(),v.end(), [&](int val){
//val就是m容器中的key值
cout<<m[val]<<"出场了"<<endl;
} );
}
multimap容器
- multimap可反转，经过排序的关联容器，但键和值的类型不同，且同一个键可能与多个值相关联。
- 基本的multimap声明使用模板参数指定键的类型和存储的值类型。例:multimap<int,string> codes;
map和multimap的区别：
- map不允许容器中有重复key值元素
- multimap允许容器中有重复key值元素
例：
#include <iostream>
#include<string>
#include<map>
#include<algorithm>
using namespace std;
typedef int KeyType;
typedef pair<const KeyType,string> Pair;
typedef multimap<KeyType,string> MapCode;
int main()
{
MapCode codes;
codes.insert(Pair(415,"San Franciscon"));
codes.insert(Pair(510,"Oakland"));
codes.insert(Pair(718,"Brooklyn"));
codes.insert(Pair(718,"Staten Island"));
codes.insert(Pair(415,"San Rafael"));
codes.insert(Pair(510,"Berkeley"));
cout<<"Number of cities with area code 415:"
<<codes.count(415)<<endl;
cout<<"Number of cities with area code 718:"
<<codes.count(718)<<endl;
cout<<"Number of cities with area code 510:"
<<codes.count(510)<<endl;
cout<<"Area Code City\n";
MapCode::iterator it;
for(it=codes.begin();it!=codes.end();it++)
cout<<" "<<(*it).first<<" "
<<(*it).second<<endl;
pair<MapCode::iterator,MapCode::iterator>
range=codes.equal_range(718);//用键作为参数，且f返回两个迭代器，表示区间与该键匹配
cout<<"Cityies with area code 718:\n";
for(it=range.first;it!=range.second;it++)
cout<<(*it).second<<endl;
return 0;
}
注：
1.如果Keytype是键类型，而datatype是存储的数据类型，则值类型为pair<const keytype,datatype>。
2代码中打印codes对象中718所有城市可在声明中可使用c++11自动类型推断功能代码，代码如下：
auto range=codes.equal_range(718);
cout<<"City with area code 718:\n";
for(auto it=range.first;it!=range.second;it++)
cout<<(*it).second<<endl;
案例
#include <iostream>
#include<vector>
#include<map>
#include<algorithm>
using namespace std;
class Person
{
public:
string name;
int age;
Person(string name,int age)
{
this->name=name;
this->age=age;
}
};
void createVectorPerson(vector<Person> &v)
{
v.push_back(Person("员工A", 21));
v.push_back(Person("员工B", 23));
v.push_back(Person("员工C", 21));
v.push_back(Person("员工D", 22));
v.push_back(Person("员工E", 21));
}
void PersonByGroup(vector<Person> &v,multimap<int,Person> &m)
{
//逐个将员工配到 各个部门内
for(vector<Person>::iterator it=v.begin();it!=v.end();it++)
{
//*it=Person
cout<<"请输入"<<(*it).name<<"加入部门:1 2 3"<<endl;
int operate=0;
cin>>operate;
if(operate>=1 && operate<=3)
{
m.insert(make_pair(operate,*it));
}
}
}
void showPersonList(multimap<int, Person> &m, int op)
{
switch (op) {
case 1:
cout<<"研发部:"<<endl;
break;
case 2:
cout<<"测试部:"<<endl;
break;
case 3:
cout<<"人事部:"<<endl;
break;
}
//注意：m中存放的数据《部门号、员工信息》
//统计相同部门号的元素个数
int n = m.count(op);
cout<<"部门的人数个数："<<n<<endl;
//由于 multimap将key自动排序 重复 相同key一定挨在一起
multimap<int, Person>::const_iterator ret;
ret = m.find(op);
if(ret != m.end())//寻找到key
{
for(int i=0;i<n;i++,ret++)
{
//(*ret) == <int, Person>
//(*ret).second == Person
cout<<"name = "<<(*ret).second.name<<",age = "<<
(*ret).second.age<<endl;
}
}
}
int main()
{
//使用vector容器将员工信息存储起来
vector<Person> v;
//创建5名员工
createVectorPerson(v);
//将员工分配到不同的部门（员工<部门号、员工信息>）
multimap<int, Person> m;//存放员工<部门号、员工信息>
PersonByGroup(v, m);
//按部门查看员工信息
showPersonList(m, 1);
showPersonList(m, 2);
showPersonList(m, 3);
}
无序关联容器
无序关联容器是对容器概念的另一种改进，与关联容器一样，无序关联容器也将也将值与键关联起来，并使用键来查找值。但底层的区别在于，关联容器是基于树结构的，而无序关联容器是基于数据结构哈希表的，旨在提高添加和删除元素的速度以及提高查找算法的效率。有四种无序关联容器：
unordered_set,unordered_multiset,unordered_map和unordered_multimap.
1575
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
