
void test_set1()
{
	set<int> s;
	s.insert(4);
	s.insert(5);
	s.insert(2);
	s.insert(1);
	s.insert(1);
	s.insert(3);
	s.insert(2);
	s.insert(1);
 
 
	// 排序 + 去重 
	set<int>::iterator it = s.begin();
	while (it != s.end())
	{
		//*it = 10;    迭代器不支持修改
		cout << *it << " ";
		++it;
	}
	cout << endl;
 
    for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;
}

set中的普通迭代器就是用的const迭代器！！

3.find

能找到就返回元素的迭代器，找不到就返回end

set::find和std::find对比

set::find 搜索二叉树特性查找，时间复杂度是O(logN)

全局的find 是暴力查找，时间复杂度是O(N)

所以set::find效率更高


void test_set2()
{
	set<int> s;
	s.insert(4);
	s.insert(5);
	s.insert(2);
	s.insert(1);
	s.insert(1);
	s.insert(3);
	s.insert(2);
	s.insert(1);
 
	set<int>::iterator pos = s.find(20);  // O(logN)
	if (pos != s.end())
	{
		cout << "set.find找到了" << endl;
	}
 
	pos = find(s.begin(), s.end(), 2); // O(N)
	if (pos != s.end())
	{
		cout << "find找到了" << endl;
	}
}

4.erase

size_type就是size_t，也就是unsigned int

(1) void erase (iterator position); 必须加检查if (pos != s.end()) s.erase(pos); 因为有pos时，正常运行，如果没有pos，就会报错。例如：s.erase(pos);

(2)size_ type erase (const value_ type& val) ; 则可以随便删，无论有没有都不报错例如：s.erase(3)

(3)void erase (iterator first，iterator last) 删的是[ first， last），即不包含 last


void test_set3()
{
	set<int> s;
	s.insert(4);
	s.insert(5);
	s.insert(2);
	s.insert(1);
	s.insert(1);
	s.insert(3);
	s.insert(2);
	s.insert(1);
 
	cout << s.erase(3) << endl;    //有就返回1
	cout << s.erase(30) << endl;   //没有就返回0
 
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;
 
	set<int>::iterator pos = s.find(3);
	if (pos != s.end())
		s.erase(pos);
 
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;

5.swap 根节点交换

6.count 比find方便


 
	if (s.count(5))
	{
		cout << "5在" << endl;
	}
 
	if (s.find(5) != s.end())
	{
		cout << "5在" << endl;
	}

打印：

5在

7.lower_bound：返回>= val得位置迭代器

（1）lower_bound

返回>= val得位置迭代器 3返回3位置 6 返回7位置


返回>= val的位置迭代器 3返回3位置 6 返回7位置
    set<int> s;
	s.insert(4);
	s.insert(5);
	s.insert(1);
	s.insert(3);
	s.insert(2);
	s.insert(7);
	s.insert(9);
    set<int>::iterator lowIt = s.lower_bound(3); 存在
	lowIt = s.lower_bound(6); 不存在

用途：举例：要求删除>=x的所有值：


void test_set4()
{
	set<int> s;
	s.insert(4);
	s.insert(5);
	s.insert(1);
	s.insert(3);
	s.insert(2);
	s.insert(7);
	s.insert(9);
    for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;
 
	// 要求删除>=x的所有值
	int x;
	cin >> x;
	set<int>::iterator lowIt = s.lower_bound(x);
	s.erase(lowIt, s.end());
 
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;
}

（2）upper_bound 返回>x位置的迭代器

返回>x位置的迭代器，s.upper_bound(5) 存在5，不存在6，则返回7；s.upper_bound(6) 不存在6，返回7；


    set<int> s;
	s.insert(4);
	s.insert(5);
	s.insert(1);
	s.insert(3);
	s.insert(2);
	s.insert(7);
	s.insert(9);
 
	返回>x位置的迭代器  -》 都是返回 7位置的迭代器
	set<int>::iterator upIt = s.upper_bound(5);  // 存在
	upIt = s.upper_bound(6); // 不存在

用途：例如删除x <= <= y的区间删除 [x,y]


void test_set4()
{
	set<int> s;
	s.insert(4);
	s.insert(5);
	s.insert(1);
	s.insert(3);
	s.insert(2);
	s.insert(7);
	s.insert(8);
 
	// 返回>= val得位置迭代器  3返回3位置  6 返回7位置
	/*set<int>::iterator lowIt = s.lower_bound(3); 存在
	lowIt = s.lower_bound(6); 不存在*/
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;
 
	// 删除x <=  <= y的区间 删除 [x,y]
	int x, y;
	cin >> x >> y;
	auto leftIt = s.lower_bound(x);  // [
	auto rightIt = s.upper_bound(y); // )
	s.erase(leftIt, rightIt);
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;
}

8. std::multiset 跟set接口一样，只是允许冗余，不去重

插入重复的数时set会去重，multiset不去重，允许冗余

不同：

multiset 的count和erase 返回查找或删除个数

find(x) 多个x的话，find返回中序第一个x


void test_set6()
{
	multiset<int> s;
	s.insert(4);
	s.insert(5);
	s.insert(2);
	s.insert(1);
	s.insert(1);
	s.insert(3);
	s.insert(2);
	s.insert(1);
	s.insert(3);
	s.insert(3);
	s.insert(3);
	s.insert(3);
 
	// 排序 
	set<int>::iterator it = s.begin();    //迭代器打印
	while (it != s.end())
	{
		//*it = 10;
		cout << *it << " ";
		++it;
	}
	cout << endl;
 
	for (auto e : s)        //范围for打印
	{
		cout << e << " ";
	}
	cout << endl;
 
	cout << s.count(1) << endl;    //测试count，打印3，因为1有3个
	cout << s.erase(1) << endl;    //测试erase，打印3，因为1有3个
	for (auto e : s)    
	{
		cout << e << " ";
	}
	cout << endl;
                           
	auto pos = s.find(3);         // 多个x的话，find返回中序第一个x
	while (pos != s.end())        //从中序第一个3开始打印完整个
	{
		cout << *pos << " ";
		++pos;
	}
	cout << endl;
}

9.set相关题目

349. 两个数组的交集

方法一：把nums1和nums2分别放进s1和s2中进行去重，再利用范围for把s2中的每个元素在s1中进行查找，如果找到就放进v中。时间复杂度是：O(n*logn) n个节点，每个节点找logn高度次


class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        //去重
        set<int> s1;
        for(auto e:nums1)
        {
            s1.insert(e);
        }
        //去重
        set<int> s2;
        for(auto e:nums2)
        {
            s2.insert(e);
        }
        vector<int> v;
        for(auto e:s2)
        {
            if(s1.count(e))
            {
                v.push_back(e);
            }
        }
        return v;
    }
};

方法二：


class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        set<int> s1;
        for(auto e:nums1)
        {
            s1.insert(e);
        }
 
        set<int> s2;
        for(auto e:nums2)
        {
            s2.insert(e);
        }
        vector<int> v;
        set<int>::iterator it1=s1.begin();
        set<int>::iterator it2=s2.begin();
        while(it1!=s1.end() && it2!=s2.end())
        {
            if(*it1>*it2)    //相比较，值小的++
            {
                ++it2;
            }
            else if(*it1<*it2)    //相比较，值小的++
            {
                ++it1;
            }
            else                //相比较，值相等就放进v中，同时++
            {
                v.push_back(*it1);
                ++it1;
                ++it2;
            }
        }
        return v;
    }
};

二.map用法介绍

map是KV模型的搜索二叉树，insert和[]用法是重点，其他用法参考set #include<map>

几个map和set的冷知识：

map：

①map是C++98中已存在的，unordered_map是C++11中才有的

②map中都重载了[]运算符，multimap中没有重载[]运算符，set也没有重载[]。

原因：map中key是唯一的，每个key都有与之对应的value，经常需要通过key获取value，因此 map为了形象简单就重载了[]运算符, multimap中key是可以重复的，如果重载了[]运算符，给定一个key时，就没有办法返回 value了，因此，multimap中没有重载[]运算符

③map中key不能修改，因为如果修改了就不能保证红黑树的有序特性了

set：

①set中也可以存储键值对，实例化set时，将set中元素类型设置为pair即可

②set默认是升序，但是其内部默认不是按照大于比较，而是按照 less小于比较

less是把小的放左边，所以是升序；greater是把大的放左边，所以是降序

③map和set查询的时间复杂度都是O(log_2N)

解释：map和set的底层结构都是红黑树，而红黑树是近似的平衡二叉搜索树，故查询时间复杂度为O(log_2N)

④map和set底层都是使用红黑树实现的

1.pair和make_pair

（1）pair键值对的介绍

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

表键值，value表示与key对应的信息。比如：现在要建立一个英汉互译的字典，那该字典中必然

有英文单词与其对应的中文含义，而且，英文单词与其中文含义是一一对应的关系，即通过该应

该单词，在词典中就可以找到与其对应的中文含义。

pair 打包了KV模型的key和val两个类型的值，c++不支持返回两个值，也就不知道返回key和val哪一个了，所以干脆打包key和val，返回一个pair结构

（value_type 是 pair<const key_type,mapped_type>）

pair中的first就相当于KV模型中的key，second相当于KV模型中的val

（2）make_pair 介绍

make_pair 相当于返回了一个pair的匿名对象

2.map的遍历

（1）英汉字典的遍历

几种插入英汉字典的方式：匿名对象插入，普通对象插入，make_pair插入


void test_map1()
{
	map<string, string> dict;
 
	// pair构造函数
	dict.insert(pair<string, string>("sort", "排序")); //匿名对象插入更便捷
	pair<string, string> kv("insert", "插入");    //普通对象插入
	dict.insert(kv);
 
	// make_pair
	auto ret1 = dict.insert(make_pair("left", "左边"));  //make_pair插入
	auto ret2 = dict.insert(make_pair("left", "剩余"));
	// 遍历
//map<string, string>::iterator it = dict.begin();
	auto it = dict.begin();
	while (it != dict.end())
	{
		//cout << *it << " "; // it->operator*()
		//cout << (*it).first << ":" << (*it).second << endl;
		cout << it->first << ":" << it->second << endl;
		++it;
	}
	cout << endl;
 
	for (const auto& kv : dict)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
}
 
int main()
{
	test_map1();
	return 0;
}

（2）记录水果次数


void test_map2()
{
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
	map<string, int> countMap;
	for (auto& str : arr)
	{
		map<string, int>::iterator it = countMap.find(str);	
		if (it != countMap.end())	//如果countMap中有，就计数加1
		{
			it->second++;
		}
		else
		{
			countMap.insert(make_pair(str, 1));	//没有就插入水果
		}
	}
	for (auto& str : arr)
	{
		countMap[str]++;
	}
	for (const auto& kv : countMap)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
}

3.insert写法提高记录水果次数的效率（不这么写，只是为[]做铺垫）

map的insert默认是按照pair中的first进行排序的


    string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
	map<string, int> countMap;
	for (auto& str : arr)
	{
pair<map<string, int>::iterator, bool> ret = countMap.insert(make_pair(str, 1));
		//或者 auto ret = countMap.insert(make_pair(str, 1));
		if (ret.second == false)
		{
			ret.first->second++;
		}
	}
	for (const auto& kv : countMap)
	{
		cout << kv.first << ":" << kv.second << endl;
	}

解释：

pair<map<string, int>::iterator, bool> ret = countMap.insert(make_pair(str, 1)) 插入节点，若插入成功，ret.first这个iterator 存的是新插入节点的迭代器，ret.second 存的是true；若插入失败，ret.first这个iterator 存的是已有的相同节点的迭代器，ret.second 存的是false；插入失败就再记录个数++就行，ret.first->second++; 用于访问记录水果个数，ret.first 是节点迭代器，ret.first->second++; 节点中的second用于记录对应水果的个数

4.operator[] 运算符重载

（1）提高记录水果次数的效率的真正写法：


void test_map2()
{
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
	map<string, int> countMap;
	for (auto& str : arr)
	{
		countMap[str]++;
	}
 
	for (const auto& kv : countMap)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
}

解释：

countMap[str]++; 中 countMap[str] 返回的是新插入节点中的次数second 。

如果插入的str不在对象countMap中，countMap[str]++; 就是插入这个节点，迭代器就是新节点的迭代器，看原码可知 int类型的次数second用的是缺省值（对应原码中的mapped_typed()，是缺省值），所以开始second就是0，++后就是1。作用就是插入并修改val (val意思就是second)。

如果插入的str在对象countMap中，countMap[str]++; 就是查找到这个节点，迭代器就是已有节点的迭代器，int类型的次数second在第一次已经是1了，++后就是2。作用就是插入并修改val (val意思就是second，用于计水果次数)。

（2）字典中利用[]插入或修改示例


void test_map1()
{
	map<string, string> dict;
 
	// pair构造函数
	dict.insert(pair<string, string>("sort", "排序"));
	pair<string, string> kv("insert", "插入");
	dict.insert(kv);
 
	// make_pair
	auto ret1 = dict.insert(make_pair("left", "左边"));
	auto ret2 = dict.insert(make_pair("left", "剩余"));
 
	dict["operator"] = "重载"; // 插入+修改
	dict["left"] = "左边、剩余"; // 修改
	dict["erase"];  // 插入
	cout << dict["left"] << endl; // 查找
}

5.multimap 允许键值冗余

相比map，multimap使用函数接口最大的区别是什么?
答：不支持operator[] 。

三.相关题目

1.692. 前K个高频单词

（1）做法一：stable_sort稳定排序

把map中的pair放到v中再用stable_sort稳定排序，再把各个pair对应的first放到vv中，再输出vv


class Solution {
public:
    typedef map<string,int>::iterator CountIter;
    struct less
    {
        bool operator()(const pair<string,int>& x,const pair<string,int>& y)
        {
            return x.second>y.second;
        }
    };
 
    vector<string> topKFrequent(vector<string>& words, int k) {
        map<string,int> countMap;
        for(auto& str:words)
        {
           countMap[str]++;
        }
 
        vector<pair<string,int>> v;
        CountIter it=countMap.begin();
        while(it!=countMap.end())
        {
            //cout<<it->first<<" "<<it->second<<endl;
            v.push_back(*it);
            ++it;
        }
 
        stable_sort(v.begin(),v.end(),less());  //stable_sort稳定排序
        vector<string> vv;
        for(int i=0;i<k;i++)
        {
            vv.push_back(v[i].first);
        }
        for(auto e:v)
        {
            cout<<e.first<<" "<<e.second<<endl;
        }
        return vv;
    }
};

（2）做法二：stable_sort稳定排序 2

与做法一不同的是：pair很大，为了减少拷贝，我们可以选择不拷贝pair而是拷贝迭代器，把map中的迭代器放到v中，比较方法中通过迭代器找到second，再用stable_sort稳定排序这些迭代器，再把各个迭代器对应的first放到vv中，再输出vv

自己敲的：


class Solution {
public:
    typedef map<string,int>::iterator CountIter;
    struct less //降序
    {
        bool operator()(const CountIter& x,const CountIter& y)
        {
            return x->second > y->second;
        }
    };
    
    vector<string> topKFrequent(vector<string>& words, int k) {
        map<string,int> countMap;
        for(auto& str:words)
        {
           countMap[str]++;
        }
 
        vector<CountIter> v;
        CountIter it=countMap.begin();
        while(it!=countMap.end())
        {
            //cout<<it->first<<" "<<it->second<<endl;
            v.push_back(it);
            ++it;
        }
 
        stable_sort(v.begin(),v.end(),less());  //stable_sort稳定排序
        for(auto e:v)
        {
            cout<<e->first<<" "<<e->second<<endl;
        }
        vector<string> vv;
        for(int i=0;i<k;i++)
        {
            vv.push_back(v[i]->first);
        }
        
        return vv;
    }
};

（3）做法三：sort 非稳定排序，可以控制比较方法使其稳定

相比较上面的方法，把stable_sort换成sort后，只需要控制比较方法即可使其稳定：因为map中默认是按照分first小的在前排序的，sort 时我们设计的比较方法是按second排序的，但是当second相等时，sort有可能打乱之前map中按 first 排的先后顺序，这样就是不稳定。我们只需要比较方法中让second相等时的情况再按first小的在前排好就可以达到稳定的目的。（相等时会多比一下first，会影响一点效率）