【初阶与进阶C++详解】第十八篇：map_set（map_set使用+multiset_multimap使用+模拟map_set）

🏆个人主页：企鹅不叫的博客

​ 🌈专栏

• C语言初阶和进阶
• C项目
• Leetcode刷题
• 初阶数据结构与算法
• C++初阶和进阶
• 《深入理解计算机操作系统》
• 《高质量C/C++编程》
• Linux

⭐️ 博主码云gitee链接：代码仓库地址

⚡若有帮助可以【关注+点赞+收藏】，大家一起进步！

💙系列文章💙

【初阶与进阶C++详解】第一篇：C++入门知识必备

【初阶与进阶C++详解】第二篇：C&&C++互相调用（创建静态库）并保护加密源文件

【初阶与进阶C++详解】第三篇：类和对象上（类和this指针）

【初阶与进阶C++详解】第四篇：类和对象中（类的六个默认成员函数）

【初阶与进阶C++详解】第五篇：类和对象下（构造+static+友元+内部类

【初阶与进阶C++详解】第六篇：C&C++内存管理（动态内存分布+内存管理+new&delete）

【初阶与进阶C++详解】第七篇：模板初阶（泛型编程+函数模板+类模板+模板特化+模板分离编译）

【初阶与进阶C++详解】第八篇：string类（标准库string类+string类模拟实现）

【初阶与进阶C++详解】第九篇：vector(vector接口介绍+vector模拟实现+vector迭代器区间构造/拷贝构造/赋值)

【初阶与进阶C++详解】第十篇：list(list接口介绍和使用+list模拟实现+反向迭代器和迭代器适配)

【初阶与进阶C++详解】第十一篇：stack+queue+priority_queue+deque（仿函数）

【初阶与进阶C++详解】第十二篇：模板进阶(函数模板特化+类模板特化+模板分离编译)

【初阶与进阶C++详解】第十三篇：继承(菱形继承+菱形虚拟继承+组合)

【初阶与进阶C++详解】第十四篇：多态（虚函数+重写（覆盖）+抽象类+单继承和多继承）

【初阶与进阶C++详解】第十五篇：二叉树搜索树（操作+实现+应用KVL+性能+习题）

【初阶与进阶C++详解】第十六篇：AVL树-平衡搜索二叉树（定义+插入+旋转+验证）

【初阶与进阶C++详解】第十七篇：红黑树（插入+验证+查找）

---

---

💎一、关联式容器

关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的键值对，在数据检索时比序列式容器效率更高 。底层是红黑树实现的，容器中元素都是有序序列

💎二、键值对

用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值，value表示与key对应的信息。

set存放的是<value, value> ，map存放的是<value, value>。

map<string, string> dict;

	dict.insert(pair<string, string>("you", "你"));
	dict.insert(make_pair("wo", "我"));
	pair<string, string> kv("ta", "他");
	dict.insert(kv);

💎三、set使用

🏆1.set介绍

1.set是按照一定次序存储元素的容器
2.在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。
3.在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。
4.set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭代。
5.set在底层是用红黑树实现的。

🏆2.set构造

set (const Compare& comp = Compare(), const Allocator& = Allocator() );	构造空的set
set ( const set<Key,Compare,Allocator>& x);	set的拷贝构造
set (InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator() );	用[first, last)区 间中的元素构造 set

🏆3.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

🏆4.set容量

size_type size() const	返回set中有效元素的个数
bool empty ( ) const	检测set是否为空，空返回true，否则返回true

🏆5.set修改

pair<iterator,bool> insert ( const value_type& x )	插入元素，返回值是键值对，其中如果第二个参数为true，那么第一个参数是插入元素的迭代器的位置，为false的话，第一个参数就是已经存在元素的迭代器的位置
void erase ( iterator position )	删除set中position位置上的元素
size_type erase ( const key_type& x )	删除set中值为x的元素，返回删除的元素的个数
void erase ( iterator first, iterator last )	删除set中[first, last)区间中的元素
iterator find ( const key_type& x ) const	返回set中一个迭代器，指向元素x的位置，如果没有找到这个元素就返回end，时间复杂度为O(logN)，比算法中的find（时间复杂是O(N)）更高效。
size_type count ( const key_type& x ) const	查找二叉树中value值的个数,返回set中值为x的元素的个数
iterator lower_bound (const value_type& val)	包含在头文件，返回指向等于或大于指定键值元素的迭代器，如果更大的键值或者它本身不存在，就会返回一个end迭代器，10 10 20 20 30，如果指定元素是20，返回第一个20
iterator upper_bound (const value_type& val)	包含在头文件，返回指向大于指定键值元素的迭代器，如果更大的键值或者它本身不存在，就会返回一个end迭代器，10 10 20 20 30，如果指定元素是20，则返回第一个30

演示：

void test_set()
{

	set<int> s;

	s.insert(5);
	s.insert(4);
	s.insert(2);
	s.insert(3);
	s.insert(1);
	s.insert(s.begin(), 6);

	set<int>::iterator pos = s.find(1);// 底层是搜索二叉树，时间复杂度是O(logN)
	// set<int>::iterator pos = find(s.begin(), s.end(), 1);// 遍历查找，时间复杂度是O(N)
	if (pos != s.end())
	{
		s.erase(pos);
	}
	set<int>::iterator it = v1.find(3);
	if (it != s.end())
	{
		cout << "找到了 "<< *it << endl;
	}
-------------------------------------------
 set<int> s;

	for (int i = 1; i < 6; ++i)
	{
		//1 2 3 4 5
		s.insert(i);
	}
	set<int>::iterator it = s.lower_bound(3);
	//返回等于或大于3的第一个位置迭代器，输出3
	cout << "lower_bound" << *it << endl;

	it = s.upper_bound(3);
	//返回大于3的第一个位置的迭代器，输出4
	cout << "upper_bound" << *it << endl;

	for (int i = 2; i < 6; ++i)
	{
		//插入 2 3 4 5
		//变成 1 2 2 3 3 4 4 5 5
		s.insert(i);
	}
	set<int>::iterator it = s.lower_bound(3);
	//返回等于或大于3的第一个位置迭代器，输出第一个位置的3
	cout << "lower_bound" << *it << endl;

	it = s.upper_bound(3);
	//返回大于3的第一个位置的迭代器，输出4
	cout << "upper_bound" << *it << endl;
}

🏆6.multiset介绍和使用

multiset与set的区别是，multiset中的元素可以重复，set是中value是唯一的 ，其他参照set

1. count：返回的是元素x的个数
2. erase：删除序列中所有x
3. find：返回序列中第一个x

💎四、map使用

🏆1.map介绍

1.map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
2.在内部，map中的元素总是按照键值key进行比较排序的。
3.map中通过键值访问单个元素的速度通常比unordered_map容器慢，但map允许根据顺序对元素进行直接迭代(即对map中的元素进行迭代时，可以得到一个有序的序列)。
4.map支持下标访问符，支持operator[]，即在[]中放入key，就可以找到与key对应的value。
5.map通常被实现为二叉搜索树(更准确的说：平衡二叉搜索树(红黑树))

🏆2.map构造

map()	构造一个空map
map(const map& m)	拷贝构造

🏆3.map迭代器

begin()和end()	begin:首元素的位置，end最后一个元素的下一个位置
cbegin()和cend()	与begin和end意义相同，但cbegin和cend所指向的元素不 能修改
rbegin()和rend()	反向迭代器，rbegin在end位置，rend在begin位置，其 ++和–操作与begin和end操作移动相反
crbegin()和crend()	与rbegin和rend位置相同，操作相同，但crbegin和crend所 指向的元素不能修改

C++中如果使用std::map或者std::multimap可以对key排序，但不能对value排序。
所以要把map转化数组即vector，再进行排序，当然vector里面放的也是pair<int, int>类型的数据，第一个int为元素，第二个int为出现频率。

bool static cmp (const pair<int, int>& a, const pair<int, int>& b) {
    return a.second > b.second; // 按照频率从大到小排序
}

vector<pair<int, int>> vec(map.begin(), map.end());
sort(vec.begin(), vec.end(), cmp); // 给频率排个序

🏆4.map容量

bool empty ( ) const	检测map中的元素是否为空，是返回 true，否则返回false
size_type size() const	返回map中有效元素的个数

🏆5.map修改

pair<iterator,bool> insert ( const value_type& x )	在map中插入键值对x，注意x是一个键值对，返回值也是键值对：iterator代表新插入 元素的位置，bool代表释放插入成功
void erase ( iterator position )	删除position位置上的元素
size_type erase ( const key_type& x )	删除键值为x的元素
void erase ( iterator first, iterator last )	删除[first, last)区间中的元素
iterator find ( const key_type& x )	在map中插入key为x的元素，找到返回该元 素的位置的迭代器，否则返回end
const_iterator find ( const key_type& x ) const	在map中插入key为x的元素，找到返回该元 素的位置的const迭代器，否则返回cend
size_type count ( const key_type& x ) const	返回key为x的键值在map中的个数，注意 map中key是唯一的，因此该函数的返回值 要么为0，要么为1，因此也可以用该函数来 检测一个key是否在map中

部分演示：

//map插入和迭代器的使用
	map<string, string> dict;

	dict.insert(pair<string, string>("sort", "排序"));
	pair<string, string> kv("insert", "插入");
	dict.insert(kv);
	auto ret1 = dict.insert(make_pair("left", "左边"));
	// 遍历
	map<string, string>::iterator it = dict.begin();
	while (it != dict.end())
	{
		//cout << *it << " "; // 返回值pair不支持流，每次返回只能返回一个值，pair里面有两个值
 	//it-> 返回 值的地址  -> 解引用访问两个元素
		cout << it->first << ":" << it->second << endl;
		++it;
	}
	cout << endl;

	for (const auto& kv : dict)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
--------------------------------------------------
//统计次数
map<string, int> countMap;

	string fruitArray[] = { "西瓜","桃子","香蕉","桃子","苹果","西瓜", "香蕉","苹果", "香蕉","西瓜","桃子", "西瓜", "西瓜","桃子",
	"桃子", "桃子", "西瓜","桃子","香蕉","桃子","苹果","西瓜" };

	//方法一
	for (auto& e : fruitArray)
	{
		map<string, int>::iterator ret = countMap.find(e);
		if (ret != countMap.end())// 找到了，说明容器里有，第二个参数加1即可
		{
			++ret->second;
		}
		else
		{
			// 没有就插入，第二个参数记为1
			countMap.insert(make_pair(e, 1));
		}
	}

	// 方法二
	for (auto& e : fruitArray)
	{

		// countMap无此元素，pair的第一个参数返回新的迭代器，第二个参数返回true
		// countMap有此元素，pair的第一个参数返回旧的迭代器，第二个参数返回false
		pair<map<string, int>::iterator, bool> ret = countMap.insert(make_pair(e, 1));

		// 插入失败，只需要++value即可 

		if (ret.second == false)
		{
			++ret.first->second;
		}
	}

🏆6.operator[]（重点）

下面是operator官方定义，operato[]的底层是用到了插入，同时可以对value进行访问和修改。

mapped_type& operator[] (const key_type& k) 
{ 
	return (*((this->insert(make_pair(k,mapped_type()))).first)).second; 
}
//化简
mapped_type& operator[] (const key_type& k) 
{ 
	//如果k在对象中，则插入失败，返回值是false
	//如果k不在对象中，则插入成功，返回值是true
	//mapped_type()是默认类型
	  pair<iteraotr, bool>ret = insert(make_pair(k, mapped_type()));
	//ret.first是迭代器
	return ret.first->second; 
}

统计水果次数的第三种方法

map<string, int> countMap;
string fruitArray[] = { "西瓜","桃子","香蕉","桃子","苹果","西瓜", "香蕉","苹果", "香蕉","西瓜","桃子", "西瓜", "西瓜","桃子","桃子", "桃子", "西瓜","桃子","香蕉","桃子","苹果","西瓜" };

// 方法三
	for (auto& e : fruitArray)
	{
		countMap[e]++;// 有插入、查找和修改的功能   返回value的值的引用 
	}

	countMap["梨子"];// 插入
	countMap["梨子"] = 5;// 修改
	cout << countMap["梨子"] << endl;// 查找  一般不会用 operator[] 来进行查找，因为没找到会进行插入
	countMap["哈密瓜"] = 3;// 插入+修改

	for (auto& e : countMap)
	{
		cout << e.first << ":" << e.second << endl;
	}

🏆7.multimap介绍和使用

multimaps是关联式容器，它按照特定的顺序，存储由key和value映射成的键值对<key, value>，其中多个键值对之间的key是可以重复的,底层也是红黑树，和map的性质基本类似。

multimap 和 map 的区别：可以有不同的key ，不支持operator[] 因为有多个key时，不知道返回哪个key对应的value的引用

💎五、模拟实现

利用红黑树模拟实现set和map，通过map和set构造红黑树可以看出value存的是pair<K, V>或K，对于map而言，value存的是pair<K, V>；对于set而言，value存的是K。

🏆1.模拟实现框架

1.1节点和红黑树修改

节点修改，不再创建键值对，用V代替基本类型

//改造节点
template<class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	T _data; // 数据

	Colour _col;

	RBTreeNode(const T& data)
		:_data(data)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
	{}
};

红黑树模板修改

// T决定红黑树存什么数据
// set  RBTree<K, K>
// map  RBTree<K, pair<K, V>>
// KeyOfT   支持取出T对象中key的仿函数
template<class K, class T, class KeyOfT>
class RBTree
//...

1.2map和set仿函数实现

map和set仿函数实现，我们用新增模板参数代替键值对来进行比较,两者调用同一棵树，用仿函数区分两者

template<class K, class V>
class map
{
	struct MapKeyOfV
  {
    const K& operator()(const pair<K, V>& kv)
    {
      return kv.first;//map是键值对，需要提供kv的first进行比较
    }
  };
};
template<class K>
class set
{
	struct SetKeyOfV
  {
    const K& operator()(const K& key)
    {
      return key;//set只有一个键值
    }
  };
};

1.3红黑树插入修改

修改后的插入函数,在比较方面，用仿函数代替（KeyOfT kot）

pair<iterator, bool> Insert(const T& data)
	{
		// 1、搜索树的规则插入
		// 2、看是否违反平衡规则，如果违反就需要处理：旋转
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
      	//插入成功返回新插入节点的迭代器
			return make_pair(iterator(_root), true);
		}

		KeyOfT kot;

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (kot(cur->_data) < kot(data))
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kot(cur->_data) > kot(data))
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
        		//插入失败返回已经有的节点的迭代器
				return make_pair(iterator(cur), true);
			}
		}

		cur = new Node(data);
		Node* newnode = cur;
		cur->_col = RED;  
		if (kot(parent->_data) < kot(data))
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

		cur->_parent = parent;

		// 存在连续红色节点
		while (parent && parent->_col == RED)
		{
			Node* grandfater = parent->_parent;
			assert(grandfater);

			if (grandfater->_left == parent)
			{
				Node* uncle = grandfater->_right;
				// 情况一：
				if (uncle && uncle->_col == RED) // 叔叔存在且为红
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfater->_col = RED;

					// 继续往上处理
					cur = grandfater;
					parent = cur->_parent;
				}
				else // 叔叔不存在 或者 叔叔存在且为黑
				{
					if (cur == parent->_left) // 单旋
					{
						//     g
						//   p
						// c
						RotateR(grandfater);
						parent->_col = BLACK;
						grandfater->_col = RED;
					}
					else // 双旋
					{
						//     g
						//   p
						//     c 
						RotateL(parent);
						RotateR(grandfater);
						cur->_col = BLACK;
						grandfater->_col = RED;
					}

					break;
				}
			}
			else //(grandfater->_right == parent)
			{
				Node* uncle = grandfater->_left;
				// 情况一：
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfater->_col = RED;

					// 继续往上处理
					cur = grandfater;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_right)
					{
						// g
						//   p
						//     c 
						RotateL(grandfater);
						parent->_col = BLACK;
						grandfater->_col = RED;
					}
					else // 双旋
					{
						// g
						//   p
						// c
						RotateR(parent);
						RotateL(grandfater);
						cur->_col = BLACK;
						grandfater->_col = RED;
					}

					break;
				}
			}
		}

		_root->_col = BLACK;

		return make_pair(iterator(newnode), true);
	}

1.4迭代器实现

下面是迭代器完整的模板，具体写法参考注释

template<class T, class Ref, class Ptr>
struct __RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef __RBTreeIterator<T, Ref, Ptr> Self;
	Node* _node;

	__RBTreeIterator(Node* node)
		:_node(node)
	{}

	Ref operator*()
	{
		return _node->_data;
	}

	Ptr operator->()
	{
		return &_node->_data;
	}
	//前置++
	Self& operator++()
	{
		//右为空
		if (_node->_right == nullptr)
		{
			// 找祖先里面，孩子是父亲左的那个
			Node* cur = _node;
			Node* parent = cur->_parent;
			//只要当前节点是父亲的右侧，就需要继续往上找，直到找到父亲最左侧的节点
			while (parent && parent->_right == cur)
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}

			_node = parent;
		}
		//右不为空
		else
		{
			// 找右子树的最左节点
			Node* subLeft = _node->_right;
			while (subLeft->_left)
			{
				subLeft = subLeft->_left;
			}
			//最左节点
			_node = subLeft;
		}

		return *this;
	}
	//后置++
	Self operator++(int)
	{
		Self tmp(*this);

		++(*this);

		return tmp;
	}
    //和++反着来
	//前置--
	Self& operator--()
	{
		if (_node->_left == nullptr)
		{
			// 找祖先里面，父亲是祖父节点右边的那一个
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_left)
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}

			_node = parent;
		}
        //如果左树部不为空，则找subRight最右节点
		else
		{
			// 左子树的最右节点
			Node* subRight = _node->_left;
			while (subRight->_right)
			{
				subRight = subRight->_right;
			}

			_node = subRight;
		}

		return *this;
	}
	//后置--
	Self operator--(int)
	{
		Self tmp(*this);

		--(*this);

		return tmp;
	}

	bool operator!=(const Self& s) const
	{
		return _node != s._node;
	}

	bool operator==(const Self& s) const
	{
		return _node == s->_node;
	}
};

将迭代器模板添加到红黑树中，并且准备好普迭代器和const迭代器，和begin()和end()函数

typedef __RBTreeIterator<T, T&, T*> iterator;
	typedef __RBTreeIterator<T, const T&, const T*> const_iterator;

	// 构造 拷贝构造 赋值 和析构 跟搜索树实现方式是一样的

	iterator Begin()
	{
		//中序第一个为最左节点
		Node* subLeft = _root;
		while (subLeft && subLeft->_left)
		{
			subLeft = subLeft->_left;
		}

		return iterator(subLeft);
	}

	iterator End()
	{
		return iterator(nullptr);
	}

	const_iterator Begin() const
	{
		Node* subLeft = _root;
		while (subLeft && subLeft->_left)
		{
			subLeft = subLeft->_left;
		}

		return const_iterator(subLeft);
	}

	const_iterator End() const
	{
		return const_iterator(nullptr);
	}
iterator Find(const K& key)
{
  Node* cur = _root;
  KeyOfT kot;
  while (cur)
  {
    if (kot(cur->_data) < key)
    {
      cur = cur->_right;
    }
    else if (kot(cur->_data) > key)
    {
      cur = cur->_left;
    }
    else
    {
      return iterator(cur);
    }
  }

  return End();
}

1.5find在红黑树中修改

iterator Find(const K& key)
	{
		Node* cur = _root;
		KeyOfT kot;
		while (cur)
		{
			if (kot(cur->_data) < key)
			{
				cur = cur->_right;
			}
			else if (kot(cur->_data) > key)
			{
				cur = cur->_left;
			}
			else
			{
				return iterator(cur);
			}
		}

		return End();
	}

1.6重载[]

对于map，还需要重载[]，如果键值存在也会返回当前键值的迭代器。键值不存在就能直接插入，返回新插入元素的迭代器

//重载下标
V& operator[](const K& key)
{
    pair<iterator, bool> ret = insert(make_pair(key, V()));
    return ret.first->second;//返回的是一个引用，所以可以直接修改
}

1.7封装map和set

template<class K, class V>
	class map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
    	// typename 告诉编译器这只是一个名字，暂时不用堆模板进行实例化
		typedef typename RBTree<K, pair<K, V>, MapKeyOfT>::iterator iterator;
		typedef typename RBTree<K, pair<K, V>, MapKeyOfT>::const_iterator const_iterator;

		iterator begin()
		{
			return _t.Begin();
		}

		iterator end()
		{
			return _t.End();
		}

		pair<iterator, bool> insert(const pair<K, V>& kv)
		{
			return _t.Insert(kv);
		}

		iterator find(const K& key)
		{
			return _t.Find(key);
		}

		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = insert(make_pair(key, V()));
			return ret.first->second;
		}

	private:
		RBTree<K, pair<K, V>, MapKeyOfT> _t;
	};
---------------------------------------------------------------------------
template<class K>
	class set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
    	// typename 告诉编译器这只是一个名字，暂时不用堆模板进行实例化
		typedef typename RBTree<K, K, SetKeyOfT>::const_iterator iterator;
		typedef typename RBTree<K, K, SetKeyOfT>::const_iterator const_iterator;

		iterator begin() const
		{
			return _t.Begin();
		}

		iterator end() const
		{
			return _t.End();
		}

		pair<iterator, bool> insert(const K& key)
		{
			//pair<typename RBTree<K, K, SetKeyOfT>::iterator, bool> ret = _t.Insert(key);
			auto ret = _t.Insert(key);
			return pair<iterator, bool>(iterator(ret.first._node), ret.second);
		}

		iterator find(const K& key)
		{
			return _t.Find(key);
		}
	private:
		RBTree<K, K, SetKeyOfT> _t;
	};

map和setc测试代码

void test_map()
{
	map<string, int> countMap;
	string strArr[] = { "香蕉","水蜜桃","西瓜","苹果","香蕉" ,"西瓜","香蕉" ,"苹果","西瓜","苹果","苹果","香蕉" ,"水蜜桃" };

	for (auto& e : strArr)
	{
		countMap[e]++;
	}

	countMap["芒果"] = 10;
	countMap.erase("水蜜桃");
	countMap.erase("西瓜");
	countMap.erase("芒果");
	/*countMap.erase("香蕉");
	countMap.erase("香蕉");
	countMap.erase("苹果");*/

	for (auto& e : countMap)
	{
		cout << e.first << ":" << e.second << endl;
	}

}

void test_set()
{
	set<int> s;

	int arr[] = { 1,3,2,3,4,5,1,5,5,8,3,3,2 };
	for (auto e : arr)
	{
		s.insert(e);
	}


	for (auto& e : s)
	{
		cout << e << endl;
	}

}

---