map和set的接口及其使用

set：

set是一个key的搜索模型，底层是一个平衡二叉搜索树。

应用于查找是否有key的场景

插入：insert

pair<iterator,bool> insert (const value_type& val);//插入一个值

iterator insert (iterator position, const value_type& val);//在某个位置插入一个值

template <class InputIterator>

void insert (InputIterator first, InputIterator last);//插入一段迭代器区间
 

    set<int>  SET;
	SET.insert(1);
	SET.insert(4);
	SET.insert(2);
	SET.insert(7);
	SET.insert(3);
	SET.insert(6);
	SET.insert(5);
	for (auto e : SET)
	{
		cout << e << " ";
	}
	cout << endl;

 

set的遍历支持迭代器，走的是二叉树的中序遍历，所以是有序的结果。并且因为底层是二叉搜索树，所以重复插入无效，不会有两个值相同的节点。

删除：erase

void erase (iterator position);//删除某个位置的节点

size_type erase (const value_type& val)//删除某个值的节点，返回删除元素的数量

void erase (iterator first, iterator last);//删除某段迭代器区间的值[first,last)

set<int>  SET;
	SET.insert(1);
	SET.insert(4);
	SET.insert(2);
	SET.insert(7);
	SET.insert(3);
	SET.insert(6);
	SET.insert(5);
	set<int>::iterator   begin = SET.begin();
	while (begin != SET.end())
	{
		cout << *begin << " ";
		begin++;
	}
	cout << endl;
	SET.erase(7);
	SET.erase(77);
	for (auto e : SET)
	{
		cout << e << " ";
	}
	cout << endl;

注：

 如果要删除的值存在，则进行删除；如果不存在，则没有任何作用！

查找：find

iterator find (const value_type& val) const;

 如果要查找的值存在,返回迭代器，不存在返回set::end;

如果我们要删除的值是set中存在的，我们可以find和erase配合使用

set<int>  SET;
	SET.insert(1);
	SET.insert(4);
	SET.insert(2);
	SET.insert(7);
	SET.insert(3);
	SET.insert(6);
	SET.insert(5);
	set<int>::iterator   begin = SET.begin();
	while (begin != SET.end())
	{
		cout << *begin << " ";
		begin++;
	}
	cout<<endl;
	set<int>::iterator  it=SET.find(7);
	if (it != SET.end())
	{
		SET.erase(it);
	}
	
	for (auto e : SET)
	{
		cout << e << " ";
	}
	cout << endl;

总结：

遍历set容器的结果是有序的

set支持插入、删除、查找但不允许修改

set容器中没有相同的值

erase接口只会删除存在的元素

 

map：

map是一种key-value搜索模型，应用于根据key值查找value值的场景。

map的增，删，查，遍历和set相同。

map<int, double>idmap;
	idmap.insert(pair<int, double>(1, 1.1));
	idmap.insert(pair<int, double>(5, 5.5));
	idmap.insert(pair<int, double>(2, 2.2));
	map<int, double>::iterator it = idmap.begin();
	while (it != idmap.end())
	{
		
		cout << it->first << ":" << it->second << endl;
		++it;
	}
	cout << endl;
	idmap.erase(2);
	idmap.erase(7);
	for (auto e : idmap)
	{
		cout << e.first << ":" << e.second << endl;
	}

由于map是一个Key-Value模型，在插入的时候可以用pair；一般first指向key ，second指向Value。

删除的时候是根据key值进行查找，一个map中不存在两个key值相同的结构！

接口 ： operator []

接口介绍：如果k与容器中元素的键匹配，则该函数返回对其映射值的引用。

如果k与容器中任何元素的键都不匹配，则该函数将使用该键插入一个新元素，并返回对其映射值的引用。

实现的机制：

(*(    (this->insert(make_pair(k,mapped_type() ))  ).first)).second

pair<iterator,bool> insert (const value_type& val); 

调用插入接口，存在直接返回pari结构，不存在就插入之后返回pair结构，pair.first就是该位置的迭代器，解引用，在调用second就是Value 

 应用一：统计次数

string str[] = { "西瓜", "樱桃", "西瓜", "樱桃", "西瓜", "苹果", "西瓜" };
	map<string, int> countMap;
	
	for (auto e : str)
	{
		map<string, int>::iterator ret = countMap.find(e);
		if (ret != countMap.end())
			ret->second++;
		else
			countMap.insert(pair<string, int>(e, 1));
	}
	for (auto e : countMap)
	{
		cout << e.first << ":" << e.second << endl;
	}
/
	for (auto e : str)
	{
	    pair<map<string, int>::iterator, bool> ret = countMap.insert(make_pair(e, 1));
	   if (ret.second == false)
	  {
	
	      ret.first->second++;
	  }
	}
	for (auto e : countMap)
	{
		cout << e.first << ":" << e.second << endl;
	}
///
	for (auto e : str)
	{
		countMap[e]++;
	}
	for (auto e : countMap)
	{
		cout << e.first << ":" << e.second << endl;
	}

应用二：修改key对应的value值

 

 

map<string, string> countMap;
	countMap.insert(pair<string, string>("left", "左"));
	for (auto e : countMap)
	{
		cout << e.first << ":" << e.second << endl;
	}
	countMap["left"] = "Qyuan make";
	for (auto e : countMap)
	{
		cout << e.first << ":" << e.second << endl;
	}

 注：map和set的key值不会重复，要想有多个相同的key值，可以用multimap和multiset。

      遍历map和set是有序的，所以Key必须支持比较大小