【C++】map和set的使用及注意事项

1.关联式容器

在初阶阶段，我们已经接触过STL中的部分容器，比如：vector、list、deque、forward_list(C++11)等，这些容器统称为序列式容器，因为其底层为线性序列的数据结构，里面存储的是元素本身，并且插入数据的位置是无所谓的。那什么是关联式容器？它与序列式容器有什么区别？

我们即将要学的map，set就是一种树形结构的关联式容器，也是用来存储数据的，其里面存储的是<key, value>结构的键值对，在数据检索时比序列式容器效率更高。与序列式容器不同的是，数据与数据之前有紧密的关联，插入的数据有固定的位置，正因为插入的数据有固定的位置，才能快速进行搜索。

2. 键值对

用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值，value表示与key对应的信息。比如：现在要建立一个英汉互译的字典，那该字典中必然有英文单词与其对应的中文含义，而且，英文单词与其中文含义是一一对应的关系，即通过该应该单词，在词典中就可以找到与其对应的中文含义。

键值对是一个pair类模板。，里面两个成员变量first，second。两个成员函数，一个无参构造，一个有参构造。关于它的使用我们放在map在细看，map是如何对其使用的。

template <class T1, class T2>
struct pair
{
    
    
	typedef T1 first_type;
	typedef T2 second_type;
	T1 first;
	T2 second;
	
	pair(): first(T1()), second(T2())
	{
    
    }
	pair(const T1& a, const T2& b): first(a), second(b)
	{
    
    }
};

3.set

set是一个K模型平衡搜索二叉树/红黑树。
set文档介绍

先看看它模板参数

T: set中存放元素的类型，其实换成K更合适一些，不过也没什么影响，实际在底层存储<value, value>的键值对，你可以认为它存的就只有Key值。

Compare：set中元素默认按照小于来比较。less< T> 是一个仿函数，在List模拟实现详细说过，这里不再细说。

Alloc：set中元素空间的管理方式，使用STL提供的空间配置器管理(C++学的差不多细说)。

3.1接口介绍

3.1.1构造

函数声明	功能介绍
set (const Compare& comp = Compare(), const Allocator& = Allocator() );	构造空的set
set (InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator() );	用[first, last)区间中的元素构造set
set (const set& x);	set的拷贝构造

3.1.2迭代器

函数声明	功能介绍
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

关于这个set的迭代器，建议还是先把list的迭代器学好，才能更好的理解它，因为它也不像vector那样的原生指针。它的迭代器还是封装在加上运算符重载实现的。当然也比list的更加难一些，后面模拟实现再说。

3.1.3容量

函数声明	功能介绍
bool empty ( ) const	检测set是否为空，空返回true，否则返回true
size_type size() const	返回set中有效元素的个数

3.1.4修改

函数声明	功能介绍
pair<iterator,bool> insert ( const value_type& x )	在set中插入元素x，实际插入的是<x, x>构成的键值对，如果插入成功，返回<该元素在set中的位置，true>,如果插入失败，说明x在set中已经存在，返回<x在set中的位置，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)区间中的元素
void swap (set& x);	交换set中的元素
void clear ( )	将set中的元素清空
iterator find ( const key_type& x ) const	返回set中值为x的元素的位置
size_type count ( const key_type& x ) const	返回set中值为x的元素的个数

set，multiset，map，multimap的接口差不多，后面的就不在一一介绍，接下来介绍这些容器使用注意事项。

3.2set使用及注意事项

int main()
{
    
    
	set<int> st;
	st.insert(1);
	st.insert(5);
	st.insert(2);
	st.insert(6);
	st.insert(4);
	st.insert(1);

	set<int>::iterator it = st.begin();
	while (it != st.end())
	{
    
    
		cout << *it << " ";
	}
	cout << endl;

	return 0;
}

set底层是一颗平衡搜索二叉树，但是它提供的迭代器使用和以前学过的容器一模一样，所以说它的迭代器和list一样是封装+运算符重载，不过更难一些。
看看它的打印结果。

插入的不是有序的，迭代器去走是有序的，证明它走的是中序。并且我插入了6个值，有一个相同的值没给打印，就相当于去重了。
如果以后想排序并且去重，可以使用set，更快一些。

set：排序+去重。

int main()
{
    
    
	set<int> st;
	st.insert(1);
	st.insert(5);
	st.insert(2);
	st.insert(6);
	st.insert(4);
	st.insert(1);

	set<int>::iterator it = st.begin();
	while (it != st.end())
	{
    
    
		cout << *it << " ";
		++it;
	}
	cout << endl;

	//范围for对set能不能使用？
	for (auto e : st)
	{
    
    
		cout << e << " ";
	}
	cout << endl;
	
	return 0;
}

当然是可以的，以前说过，范围for底层用的还是迭代器。所以以后想代码少些一点可以使用范围for

int main()
{
    
    
	set<int> st;
	st.insert(1);
	st.insert(5);
	st.insert(2);
	st.insert(6);
	st.insert(4);
	st.insert(1);

	set<int>::iterator it = st.begin();
	while (it != st.end())
	{
    
    
		cout << *it << " ";
		++it;
	}
	cout << endl;

	for (auto e : st)
	{
    
    
		cout << e << " ";
	}
	cout << endl;
	
	//使用auto自动识别类型更简单一些
	//set<int>::iterator pos = st.find(4);
	//有两个find，一个是set类模板提供的，另一个是算法库提供的
	//请问那个速度更快一些？
	auto pos=st.find(4);	
	auto pos = find(st.begin(), st.end(), 4);
	if (pos != st.end())
	{
    
    
		st.erase(pos);
	}

	return 0;
}

注意到算法库里面的find是暴力查找，时间复杂度O(N)，而set是一个平衡搜索叉树树，时间复杂度是O(log₂N)

set中有一个count函数，用来统计相同的值有几个。并且返回个数。

int main()
{
    
    
	set<int> st;
	st.insert(1);
	st.insert(5);
	st.insert(2);
	st.insert(6);
	st.insert(4);
	st.insert(1);

	set<int>::iterator it = st.begin();
	while (it != st.end())
	{
    
    
		cout << *it << " ";
		++it;
	}
	cout << endl;

	set<int>::iterator pos = st.find(4);
	//auto pos = find(st.begin(), st.end(), 4);
	if (pos != st.end())
	{
    
    
		st.erase(pos);
	}

	if (st.count(5))
	{
    
    

	}

	return 0;
}

用这个函数也能帮我们判断这个值在不在这个树里，返回值要不是1要不是0，那这个函数有啥用啊。
确实这个函数对set没啥用，但对multiset有用

接下来我们说一说multiset

4.multiset

multi有多重的意思。也就是说multiset允许插入相同的值。
那插入相同的值放哪里呢？

multiset的接口和set是一模一样的。不再详细介绍。

int main()
{
    
    
	multiset<int> mst;
	mst.insert(1);
	mst.insert(5);
	mst.insert(2);
	mst.insert(6);
	mst.insert(4);
	mst.insert(1);
	mst.insert(5);
	mst.insert(3);
	mst.insert(2);
	mst.insert(8);
	mst.insert(9);

	multiset<int>::iterator it = mst.begin();
	while (it != mst.end())
	{
    
    
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

迭代器走也是有序的。以后要想给数据排个序可以直接用这个。
multiset：排序
那这里就有一个问题了，有相同的元素，那find找的是那个元素？

int main()
{
    
    
	multiset<int> mst;
	mst.insert(1);
	mst.insert(5);
	mst.insert(2);
	mst.insert(6);
	mst.insert(4);
	mst.insert(1);
	mst.insert(5);
	mst.insert(3);
	mst.insert(2);
	mst.insert(8);
	mst.insert(9);

	multiset<int>::iterator it = mst.begin();
	while (it != mst.end())
	{
    
    
		cout << *it << " ";
		++it;
	}
	cout << endl;

	auto pos=mst.find(1);
	if (pos != mst.end())
	{
    
    
		mst.erase(pos);
	}
}

其实find找的是中序中的第一个出现的。

multiset允许插入相同的值，因此就可以用count来统计相同的值有多少个。

int main()
{
    
    
	multiset<int> mst;
	mst.insert(1);
	mst.insert(5);
	mst.insert(2);
	mst.insert(6);
	mst.insert(4);
	mst.insert(1);
	mst.insert(5);
	mst.insert(3);
	mst.insert(2);
	mst.insert(8);
	mst.insert(9);

	multiset<int>::iterator it = mst.begin();
	while (it != mst.end())
	{
    
    
		cout << *it << " ";
		++it;
	}
	cout << endl;

	auto pos=mst.find(1);
	if (pos != mst.end())
	{
    
    
		mst.erase(pos);
	}

	for (auto e : mst)
	{
    
    
		cout << e << " ";
	}
	cout << endl;

	cout << mst.count(5) << endl;
}

set和multiset都有这三个接口，以前我们也没学过，这里说一下，但是用的很少。

根据下面一段来说一说。

int main()
{
    
    
    std::multiset<int> mymultiset;
    std::multiset<int>::iterator itlow, itup;

    for (int i = 1; i < 8; i++) mymultiset.insert(i * 10); // 10 20 30 40 50 60 70

    itlow = mymultiset.lower_bound(30);             
    itup = mymultiset.upper_bound(40);                       

    mymultiset.erase(itlow, itup);                    // 10 20 50 60 70

    std::cout << "mymultiset contains:";
    for (std::multiset<int>::iterator it = mymultiset.begin(); it != mymultiset.end(); ++it)
        std::cout << ' ' << *it;
    std::cout << '\n';

    return 0;
}

上面就是删掉一段区间。
lower_bound(30)；返回大于等于这个值的边界
upper_bound(40)；返回大于这个值的边界
所以说这两个接口是为了方便或者左闭右开的区间的。
equal_range(30)；是获得这个值的边界。

5.map

map是一个KV模型的平衡二叉搜索树/红黑树。

key: 键值对中key的类型

T： 键值对中value的类型

Compare: 比较器的类型，map中的元素是按照key来比较的，缺省情况下按照小于来比较，一般情况下(内置类型元素)该参数不需要传递，如果无法比较时(自定义类型)，需要用户自己显式传递比较规则(一般情况下按照函数指针或者仿函数来传递)

Alloc：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的空间配置器

map的接口和set几乎完全一样。不过多了下面两个接口下面再解释。

在上面说要建立一个英汉互译的字典，那该字典中必然有英文单词与其对应的中文含义，而且，英文单词与其中文含义是一一对应的关系，即通过该应该单词，在词典中就可以找到与其对应的中文含义。这里我们就可以用map来实现。

在二叉搜索树，我们也写了KV模型的二叉搜索树，不过K和V是分开的。也可以实现上面功能。

而在map中成员类型就是最前面说过的pair类，

为什么map要把K，V放在pair，而不是分开放呢？
下面通过一段代码说明

int main()
{
    
    
	map<string, string> mp;
	//这里插入的是pair的匿名对象，不过写着太麻烦了
	mp.insert(pair<string, string>("left", "左边"));
	mp.insert(pair<string, string>("right", "右边"));
	//也可以使用下面这种简单的方式
	mp.insert(make_pair("sort", "排序"));
	
	return 0;
}

make_pair是一个函数模板，这个函数的返回值就是pair匿名对象。

int main()
{
    
    
	map<string, string> mp;
	mp.insert(pair<string, string>("left", "左边"));
	mp.insert(pair<string, string>("right", "右边"));
	mp.insert(make_pair("sort", "排序"));
	mp.insert(make_pair("string", "字符串"));

	map<string, string>::iterator it = mp.begin();
	while (it != mp.end())
	{
    
    
		cout << *it << endl;//这样写也有问题，拿不到数据
	}

	return 0;
}

从这里就可以看出，为什么map把K，V放在pair里，这里返回的是一个结构可以返回多个值，不然就只能返回一个K或V的值，

那上面代码错误是什么原因呢？
原因在于*it返回是一个pair自定义对象。而流插入对于自定义对象是没有重载的，不像就内置类型有对应的重载函数。

int main()
{
    
    
	map<string, string> mp;
	mp.insert(pair<string, string>("left", "左边"));
	mp.insert(pair<string, string>("right", "右边"));
	mp.insert(make_pair("sort", "排序"));
	mp.insert(make_pair("string", "字符串"));

	map<string, string>::iterator it = mp.begin();
	while (it != mp.end())
	{
    
    
		//*it返回的是这个对象
		cout << (*it).first<<":" <<(*it).second<< endl;
		//it->返回的是这个对象指针,这里实际是it.operator->()->first
		//这里少了一个->，是编译器帮我们自动加了
		cout << it->first << ":" << it->second << endl;
		++it;
	}

	return 0;
}

当然为了方便我们还是可以使用范围for

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

在二叉搜索树写了一段代码，统计水果的个数，今天学了map可以怎么统计呢？

	// 统计水果出现的次数
	string arr[] = {
    
     "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
   "苹果", "香蕉", "苹果", "香蕉" };

按照以前的思维，先找水果在不在，不在就插入个数+1，在就个数+1，最终统计出水果个数

int main()
{
    
    
	// 统计水果出现的次数
	string arr[] = {
    
     "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
   "苹果", "香蕉", "苹果", "香蕉" };

	map<string,int> kv;
	for (auto& str : arr)
	{
    
    
		auto it = kv.find(str);
		if (it == kv.end())
		{
    
    
			kv.insert(make_pair(str, 1));
		}
		else
		{
    
    
			it->second++;
		}
	}

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

	return 0;
}

现在有一种更为简单的方法。

int main()
{
    
    
	// 统计水果出现的次数
	string arr[] = {
    
     "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
   "苹果", "香蕉", "苹果", "香蕉" };

	map<string,int> kv;
	for (auto& str : arr)
	{
    
    
		kv[str]++;
	}

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

	return 0;
}

也能得到刚才的结果。
现在来正式介绍[ ]接口。

看到这里是不是有点头皮发麻，写的太麻烦了，但是经过分析可以找到它的重点，是一个insert接口。

insert返回值是一个pair，我们当初写二叉搜索树的时候，insert返回值写的是一个bool类型来确定是否插入成功。现在这个insert返回pair意思是什么呢？经过文档得知。

返回pair，插入成功时iteraotr指向这个最新结点，并且bool类型是true，插入失败(插入相同的key)iterator指向相同结点的指向，并且bool类型是false。

因此上面的函数就可以转换成

map的[ ]接口有三种功能
1.插入
2.修改
3.查找

int main()
{
    
    
	map<string, string> diet;
	diet.insert(pair<string, string>("right", "右边"));
	diet.insert(make_pair("sort", "排序"));
	diet.insert(make_pair("string", "字符串"));
	diet["left"];//插入

	return 0;
}

这样插入有没有问题？
没有的，这里相当于是匿名构造，对于内置类型也没有问题，假设int，那value就是默认的0。

int main()
{
    
    
	map<string, string> diet;
	diet.insert(pair<string, string>("right", "右边"));
	diet.insert(make_pair("sort", "排序"));
	diet.insert(make_pair("string", "字符串"));
	diet["left"];//插入
	diet["left"] = "左边";//修改
	diet["iterator"] = "迭代器";//插入+修改
	cout << diet["left"] << endl;//查找
	
	for (auto& diet1 : diet)
	{
    
    
		cout << diet1.first << ":" << diet1.second << endl;
	}
	return 0;
}

如果查找按照[ ]的方法去查，一定要小心，一定要确定key在才能这样查，否则就是插入了。

6.multimap

也是允许插入相同的key值。

int main()
{
    
    
	multimap<string, string> diet;
	diet.insert(make_pair("left", "左边"));
	diet.insert(make_pair("left", "剩余"));
	diet.insert(make_pair("right", "右边"));
	diet.insert(make_pair("sort", "排序"));

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

	return 0;
}

注意multimap是没有[ ]接口的。
这是因为，map是一对一的关系，而multimap是一对多的关系，如果有[ ]，那这个[ ]的返回值返回的是多的中哪一个合适呢？

并且find找的也是中序的第一个。也有count统计相同的值有多少个。

虽然是四个不同的类模板，但是它们的接口几乎一样。接口介绍就到这里。
写道题感受一下把

349. 两个数组的交集

这里介绍一个比较算法
以后遇到找并集，差集就可以用这个思路。
解题步骤：
先排序+去重
1.相等就是交集，同时++
2.不相等，小的++
有一个结束了就结束了

class Solution {
    
    
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    
    

        //去重
        set<int> s1(nums1.begin(),nums1.end());
        set<int> s2(nums2.begin(),nums2.end());

        vector<int> ret;

        //排序
        auto it1=s1.begin();
        auto it2=s2.begin();
        //比较
        while(it1 != s1.end() && it2 != s2.end())
        {
    
    
            if(*it1 == *it2)
            {
    
    
                ret.push_back(*it1);
                ++it1;
                ++it2;
            }
            else if(*it1 < *it2)
            {
    
    
                ++it1;
            }
            else
            {
    
    
                ++it2;
            }
        }

        return ret;

    }
};