C++:STL-container, algorithm, iterator knowledge points and detailed usage-map/multimap (4)
C++, the knowledge points and usage of STL containers, continue to write the last commonly used map/multimap container
Article directory
foreword
This article focuses on learning and recording the knowledge points of map/multimap and its related function usage
C++, the end of the common container knowledge points of STL containers
1. The map container
1. Concept
- All elements in the map are pairs
- The first element in the pair is key (key value), which acts as an index, and the second element is value (real value)
- All elements are automatically sorted according to the key value of the element
Essence : map/multimap is an associative container, and the underlying structure is implemented with a binary tree.
Advantages : You can quickly find the value based on the key value
The difference between map and multimap:
1. map does not allow duplicate key value elements in the container
2. multimap allows duplicate key value elements in the container
Summary:
The usage of the map container is basically the same as that of the multimap, but the map does not allow repeated key value elements, and the multimap can have repeated key value elements
2.map initialization and assignment
//初始化
map<T1, T2> mp; //map默认构造函数:
map(const map &mp); //拷贝构造函数
//赋值
map& operator=(const map &mp); //重载等号操作符
#include <map>
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));
printMap(m);
map<int, int>m2(m); //拷贝构造
printMap(m2);
map<int, int>m3;
m3 = m2; //赋值
printMap(m3);
}
int main() {
test01();
system("pause");
return 0;
}
Summary :
All elements in the map appear in pairs , and pairs should be used when inserting data
3.map size and exchange
//函数原型
size(); //返回容器中元素的数目
empty(); //判断容器是否为空
swap(st); //交换两个集合容器
#include <map>
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();
system("pause");
return 0;
}
Summary:
Statistical size - size
to determine whether it is empty - empty
swap container - swap
is basically the same as other containers, use it skillfully
4.map insertion and deletion
//函数原型
insert(elem); //在容器中插入元素。
clear(); //清除所有元素
erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(key); //删除容器中值为key的元素。
#include <map>
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(make_pair(2, 20));
//第三种插入方式
m.insert(map<int, int>::value_type(3, 30));
//第四种插入方式
m[4] = 40;
printMap(m);
//删除
m.erase(m.begin());
printMap(m);
m.erase(3);
printMap(m);
//清空
m.erase(m.begin(),m.end());
m.clear();
printMap(m);
}
int main() {
test01();
system("pause");
return 0;
}
Summary:
There are many ways to insert a map, just remember one of them
Insert—insert
delete—erase
clear—clear
Many operations are the same as other containers
5. Map search and statistics
find(key); //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
count(key); //统计key的元素个数
#include <map>
//查找和统计
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>::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();
system("pause");
return 0;
}
Summary:
Find - find (returns an iterator)
statistics - count (for map, the result is 0 or 1)
6. Map sorting
The default sorting rule of the map container is to sort from small to large according to the key value.
Focus on how to change the sorting rule
//利用仿函数，可以改变排序规则
#include <map>
class MyCompare {
public:
bool operator()(int v1, int v2) {
return v1 > v2;
}
};
void test01()
{
//默认从小到大排序
//利用仿函数实现从大到小排序
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;
}
}
int main() {
test01();
system("pause");
return 0;
}
Summary:
Use the functor to specify the sorting rules of the map container
For custom data types, the map must specify the sorting rules, which is the same as the set container
Two, map programming case
//案例描述
//公司今天招聘了10个员工（ABCDEFGHIJ），10名员工进入公司之后，需要指派员工在那个部门工作
//员工信息有: 姓名 工资组成；部门分为：策划、美术、研发
//随机给10名员工分配部门和工资
//通过multimap进行信息的插入 key(部门编号) value(员工)
//分部门显示员工信息
//实现步骤
//创建10名员工，放到vector中
//遍历vector容器，取出每个员工，进行随机分组
//分组后，将员工部门编号作为key，具体员工作为value，放入到multimap容器中
//分部门显示员工信息
//案例代码
#include<iostream>
using namespace std;
#include <vector>
#include <string>
#include <map>
#include <ctime>
/*
- 公司今天招聘了10个员工（ABCDEFGHIJ），10名员工进入公司之后，需要指派员工在那个部门工作
- 员工信息有: 姓名 工资组成；部门分为：策划、美术、研发
- 随机给10名员工分配部门和工资
- 通过multimap进行信息的插入 key(部门编号) value(员工)
- 分部门显示员工信息
*/
#define CEHUA 0
#define MEISHU 1
#define YANFA 2
class Worker
{
public:
string m_Name;
int m_Salary;
};
void createWorker(vector<Worker>&v)
{
string nameSeed = "ABCDEFGHIJ";
for (int i = 0; i < 10; i++)
{
Worker worker;
worker.m_Name = "员工";
worker.m_Name += nameSeed[i];
worker.m_Salary = rand() % 10000 + 10000; // 10000 ~ 19999
//将员工放入到容器中
v.push_back(worker);
}
}
//员工分组
void setGroup(vector<Worker>&v,multimap<int,Worker>&m)
{
for (vector<Worker>::iterator it = v.begin(); it != v.end(); it++)
{
//产生随机部门编号
int deptId = rand() % 3; // 0 1 2
//将员工插入到分组中
//key部门编号，value具体员工
m.insert(make_pair(deptId, *it));
}
}
void showWorkerByGourp(multimap<int,Worker>&m)
{
// 0 A B C 1 D E 2 F G ...
cout << "策划部门：" << endl;
multimap<int,Worker>::iterator pos = m.find(CEHUA);
int count = m.count(CEHUA); // 统计具体人数
int index = 0;
for (; pos != m.end() && index < count; pos++ , index++)
{
cout << "姓名： " << pos->second.m_Name << " 工资： " << pos->second.m_Salary << endl;
}
cout << "----------------------" << endl;
cout << "美术部门： " << endl;
pos = m.find(MEISHU);
count = m.count(MEISHU); // 统计具体人数
index = 0;
for (; pos != m.end() && index < count; pos++, index++)
{
cout << "姓名： " << pos->second.m_Name << " 工资： " << pos->second.m_Salary << endl;
}
cout << "----------------------" << endl;
cout << "研发部门： " << endl;
pos = m.find(YANFA);
count = m.count(YANFA); // 统计具体人数
index = 0;
for (; pos != m.end() && index < count; pos++, index++)
{
cout << "姓名： " << pos->second.m_Name << " 工资： " << pos->second.m_Salary << endl;
}
}
int main() {
srand((unsigned int)time(NULL));
//1、创建员工
vector<Worker>vWorker;
createWorker(vWorker);
//2、员工分组
multimap<int, Worker>mWorker;
setGroup(vWorker, mWorker);
//3、分组显示员工
showWorkerByGourp(mWorker);
测试
//for (vector<Worker>::iterator it = vWorker.begin(); it != vWorker.end(); it++)
//{
// cout << "姓名： " << it->m_Name << " 工资： " << it->m_Salary << endl;
//}
system("pause");
return 0;
}
Summary:
When the data exists in the form of key-value pairs, you can consider using map or multimap
Summarize
1. The usage of the map container is basically the same as that of the multimap, but the map does not allow repeated key value elements, and the multimap can have repeated key value elements. 2.
All elements in the map appear in pairs , and pairs should be used when inserting data.
3 .Statistics size—size, judge whether it is empty—empty, exchange container—swap, basically the same usage as other containers, use it
skillfully — clear, many operations are the same as other containers
5. Search — find (returns an iterator), statistics — count (for map, the result is 0 or 1)
6. Use the functor to specify the sorting rules of the map container, for For custom data types, map must specify the sorting rules, which are the same as set containers.
7. When data exists in the form of key-value pairs, you can consider using map or multimap
C++STL containers, common container knowledge points and detailed explanations of related functions are basically completed.
Reference Dark Horse Programmer C++