map & multimap 关联性容器-C++

梦里梦外; 2023-01-20 14:51 5阅读 0赞

![在这里插入图片描述][20210513161154265.png]

### map & multimap ###

*  目录:
 *   *  一.map模板
     *  二.Member functions
     *  三.Capacity
     *  四.Element access
     *  五.Modifiers
     *  六.Operations
     *  七.iterator
     *  八.multimap
     *  九.原理总结

# 目录: #

## 一.map模板 ##

![在这里插入图片描述][20210513151921846.png]

map<char, int> m1;

## 二.Member functions ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70]

struct classcomp{ 		//改变默认的排序方式的函数
    
    	bool operator()(const char& lhs, const char& rhs)const{ 
    
    		return lhs > rhs;	//向这里的产生>的返回方式会产生逆序的排序方式
    	}
    };
    
    bool fncomp(char lhs, char rhs) {  return lhs<rhs; }
    
    void test1(){ 
    
    	map<char, int> m1;		//简单构造
    	m1['a'] = 32;
    	m1['b'] = 33;
    	m1['c'] = 99;
    	m1['s'] = 54;
    	m1['d'] = 66;
    
    
    	map<char, int> m2(m1.begin(), m1.end());		//创建新的map变量利用迭代器传入数据
    
    	map<char, int> m3(m2);		//直接传入对应的对象也可进行复制数据
    
    	map<char, int, classcomp> m4(m1.begin(), m1.end());	//初始化,通过这里在外部定义的函数来实现改变key大小排序的方式
    
    
    	bool(*fn_pt)(char, char) = fncomp;
    	map<char, int, bool(*)(char, char)> m5(fn_pt);	//指针相关
    
    
    	map<char, int>m6;
    	m6 = m1;				//operator=赋值运算符重载来实现数据的传递
    	m1 = map<char, int>();
    
    }

## 三.Capacity ##

![在这里插入图片描述][20210513152407508.png]

void test3(){ 
    
    	map<char, int> m1;		//创建一个map对象
    	m1['s'] = 5;
    	m1['d'] = 66;		//对内部进行赋值
    	m1['a'] = 25;
    	m1['c'] = 100;
    
    	//while (!m1.empty()){} //判空操作
    
    
    	cout << m1.size() << endl;	 //输出内部现在存有的字节数
    
    	cout << m1.max_size() << endl;	//最大字节存储数
    
    }

## 四.Element access ##

![在这里插入图片描述][20210513152624544.png]

void test4(){ 
    
    	map<char, string> mymap;		//创建对象
    
    	mymap['a'] = "an element";		//传入对应的值
    	mymap['b'] = "another element";
    	mymap['c'] = mymap['b'];		//C传入b对应的value
    
    	cout << "mymap['a'] is " << mymap['a'] << '\n';		//利用operator[]将key中对应的value进行取出
    	cout << "mymap['b'] is " << mymap['b'] << '\n';
    	cout << "mymap['c'] is " << mymap['c'] << '\n';
    	cout << "mymap['d'] is " << mymap['d'] << '\n';
    
    
    	std::map<std::string, int> mymap1 = { 		//at ==查找具有指定键值的元素
    		{  "alpha", 0 },
    		{  "beta", 0 },
    		{  "gamma", 0 } };
    
    	mymap1.at("alpha") = 10;		//查找到对应的键值的对象,然后对内部进行重新赋予value
    	mymap1.at("beta") = 20;
    	mymap1.at("gamma") = 30;
    
    	for (const auto& x : mymap1) { 		//利用C++11中的auto来进行范围for操作
    		std::cout << x.first << ": " << x.second << '\n';
    	}
    
    	cout << mymap1.at("beta") << endl;
    
    }

## 五.Modifiers ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70 1]

void test5(){ 
    
    	map<char, int> m1;	//创建对象/插入数据
    
    	m1.insert(pair<char, int>('a', 10));
    	m1.insert(pair<char, int>('b', 100));	//插入
    
    
    	//map<char, int>::iterator it;
    	//it = m1.find('b'); //初始化迭代器来删除erase其中对应的值
    	//m1.erase(it);
    
    	map<char, int> m2;
    	m2.swap(m1);		//交换内部的数据
    
    	//m2.clear(); //清空
    
    	m2.emplace('x', 100);
    	m2.emplace('y', 300);	//利用emplace传入数据
    	m2.emplace('z', 400);
    
    	for (auto &e : m2)
    		cout << e.first << "-->" << e.second << endl;
    }

## 六.Operations ##

![在这里插入图片描述][20210513152702175.png]

void test7(){ 
    
    	map<char, int> m1;		//创建对象
    	m1['a'] = 10;		//插入对应的键值对的数据
    	m1['b'] = 100;
    	m1['c'] = 33;
    	m1['d'] = 45;
    	m1['d'] = 0;
    	m1['s'] = 66;
    	m1['f'] = 54;
    	m1['z'] = 15;
    	map<char, int>::iterator it;	//创建对应的迭代器
    	it = m1.find('c');				//find找到key为'c'的键值
    	for (auto& e : m1)		//利用auto将对应的数据输出
    		cout << e.first << "-->" << e.second << endl;
    		//first颞部存储的是key(键值)---second中存储的是对应的value
    
    	std::map<char, int> mymap;
    	char c;
    
    	mymap['a'] = 101;
    	mymap['c'] = 202;
    	mymap['f'] = 303;
    
    	for (c = 'a'; c<'h'; c++)
    	{ 
    		std::cout << c;
    		if (mymap.count(c)>0)	//计数内部中存在'c'的数量,在map中只有存在0或1,当存在则会执行上面的操作
    			std::cout << " is an element of mymap.\n";
    		else
    			std::cout << " is not an element of mymap.\n";
    	}
    
    
    	map<char, int>::iterator itl, itr;	//创建对应的迭代器位置
    	itl = m1.lower_bound('c');			//设置对应的边界位置
    	itr = m1.upper_bound('f');
    	m1.erase(itl, itr);		//删除对应的边界内部的数据,注意上面的数据是按顺序存放的
    
    }

## 七.iterator ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70 2]

void test2(){ 
    
    
    	map<char, int> m1;
    
    	m1['s'] = 5;	//按照键值进行排序
    	m1['d'] = 66;
    	m1['a'] = 25;
    	m1['c'] = 100;
    
    	map<char, int>::iterator it = m1.begin();			//正向迭代
    	for (it; it != m1.end(); ++it){ 
    		cout << it->first << "-->" << it->second << endl;
    	}
    
    	cout << endl;
    	map<char, int>::reverse_iterator rit = m1.rbegin();	//反向迭代
    	for (rit; rit != m1.rend(); ++rit){ 
    		cout << rit->first << "-->" << rit->second << endl;
    	}
    }

## 八.multimap ##

>  multimap和map基本一致,也是它可以存放重复键值的元素.**key可以重复**

void test(){ 
    
    	multimap<char, int> m1;	//创建对象
    	m1.insert(pair<char, int>('a', 10));		//插入数据
    	m1.insert(pair<char, int>('a', 100));		//多次插入同一键值的数据
    	m1.insert(pair<char, int>('b', 1000));
    	m1.insert(pair<char, int>('d', 10000));
    	m1.insert(pair<char, int>('d', 100000));
    	m1.insert(pair<char, int>('g', 1000000));
    	m1.insert(pair<char, int>('g', 1066));
    	m1.insert(pair<char, int>('j', 1044));
    	m1.insert(pair<char, int>('k', 1033));
    
    	multimap<char, int>::iterator it;	//创建迭代器
    	it = m1.find('a');		//迭代器找到'a'的位置,从头开始查找,到第一个'a'
    	m1.erase(it);		//删除迭代器现在所在下标的a
    	it = m1.find('a');	//再次在剩下的寻找a的数据
    	m1.erase(it);		//删除
    }

运行结果:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70 3]

>  在multimap中,如果存在两个键值一样的数据,我们不能直接通过某种方式来进行删除,只能首先利用对饮的个范围接口来确定只有a的范围,然后再进行人工的判断.

## 九.原理总结 ##

>  1.map中的元素是键值对  
> 2.map中的key是唯一的,且不可以修改  
> 3.默认按照小于的方式来对key进行比较  
> 4.map的底层是平衡搜索树(红黑树),查找的效率为 O(log2N)  
> 5.支持operator\[\]操作,可以直接进行插入查找.

[20210513161154265.png]: /images/20221021/5a50cf7443434eb0869d30274ed54880.png
[20210513151921846.png]: /images/20221021/49c2682f836b41e9a9a5fe81e717d0c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70]: /images/20221021/730498e2c1f241439f4a093d7a622b36.png
[20210513152407508.png]: /images/20221021/eb7d7d227c9f49639231d56ac60be085.png
[20210513152624544.png]: /images/20221021/59a9f9bfe2bd451784d25a7e905addca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70 1]: /images/20221021/220a45878a2843c78ba523e3dfaaa568.png
[20210513152702175.png]: /images/20221021/3a1be7c2bc24401da0229a054ab271cb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70 2]: /images/20221021/3b122d5b648f4c379b9cf626305a8a75.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70 3]: /images/20221021/d7fb5976b81a43eaa061daeeab275a61.png