STL容器大总结区分(下)

set和map基本概念

set 基本概念
简介：
所有元素都会在插入时自动被排序
本质：
set/multiset 属于 关联式容器 ，底层结构是用 二叉树 实现。
set 和 multiset 区别 ：
set 不允许容器中有重复的元素
multiset 允许容器中有重复的元素
map 基本概念
简介：
map 中所有元素都是 pair
pair 中第一个元素为 key （键值），起到索引作用，第二个元素为 value （实值）
所有元素都会根据元素的键值自动排序
本质：
map/multimap 属于 关联式容器 ，底层结构是用 二叉树 实现。
优点：
可以根据 key 值快速找到 value 值
map 和 multimap 区别 ：
map 不允许容器中有重复 key 值元素
multimap 允许容器中有重复 key 值元素

set和map构造和赋值

构造：
set<T> st ; // 默认构造函数：
set(const set &st) ; // 拷贝构造函数
赋值：
set& operator=(const set &st) ; // 重载等号操作符
构造：
map<T1, T2> mp ; //map 默认构造函数 :
map(const map &mp) ; // 拷贝构造函数
赋值：
map& operator=(const map &mp) ; // 重载等号操作符

代码实现

set

#include <iostream>
#include <vector>
#include<string>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<set>
using namespace std;
//set/multiset属于关联式容器 底层结构是用二叉树 
//set和multise区别
// 1.set不允许容器中有重复的元素
// 2.multiset允许容器有重复的元素
void printSet(set<int>&S){
	for(set<int>::iterator it=S.begin();it!=S.end();it++){
		cout<<*it<<" ";
	}
	cout<<endl;
}
 
void test01(){
	set<int> s1;
	//set插入数据时只有insert方式 
	s1.insert(10);
//	s1.insert(40);添加的 
	s1.insert(20);
	s1.insert(30);
	s1.insert(40);
	
	//遍历容器
	//set容器特点：1所有元素插入时候自动被排序
	//2set容器不允许插入重复值 
	printSet(s1);
	
	//拷贝构造
	set<int> s2(s1);
	printSet(s2);
	
	//赋值
	set<int> s3;
	s3=s2;
	printSet(s3);
	
	 
} 
int main()
{
	test01();
	system("pause");
}

map

//map中所有元素都是pair
//pair第一个元素为key(键值),起到索引作用,第二个元素为value(实值)
//所有的元素都会根据元素的键值自动排序

//本质:	map/multimap属于关联式容器,底层结构是用二叉树实现

//优点:可根据key值快速找到value值

//map不允许容器中有重复key值元素
//multimap允许容器中有重复key值元素

 #include <iostream>
#include <vector>
#include<string>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<set>
#include<map>
using namespace std;
void printMap(map<int,int>&m){
	for(map<int,int>::iterator it=m.begin();it!=m.end();it++){
		cout<<"key值="<<(*it).first<<"value="<<it->second<<endl;//打印两个值		两种表达方式都可以 
	}
	cout<<endl;
}
void test01(){
	map<int,int> m;
	m.insert(pair<int,int>(1,10));//构造方式 
	m.insert(pair<int,int>(3,20));//构造方式
	m.insert(pair<int,int>(2,30));//构造方式
	m.insert(pair<int,int>(4,40));//构造方式
	//按照key排序 
	printMap(m);
	
	//拷贝构造
	map<int,int>m2(m);
	printMap(m2);
	
	//赋值
	map<int,int>m3;
	m3=m2;
	printMap(m3); 
} 
int main()
{
	test01();
	system("pause");
}

set和map****大小和交换

功能描述：
统计 容器大小以及交换 容器
两个一样

size() ; // 返回容器中元素的数目
empty() ; // 判断容器是否为空
swap(st) ; // 交换两个集合容器

set

#include <iostream>
#include <vector>
#include<string>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<set>
using namespace std;
//没提供resize（），怕有数值重复 
void printSet(set<int> &s){
	for(set<int>::iterator it=s.begin();it!=s.end();it++){
		cout<<*it<<" ";
	}
	cout<<endl;
}

void test01(){
	set<int> s1;
	
	//插入数据
	s1.insert(10);
	s1.insert(20);
	s1.insert(40);
	s1.insert(30);
	
	//打印容器
	printSet(s1); 
	
	//判断是否为空
	if(s1.empty()){
		cout<<"s1为空"<<endl;
	} else{
		cout<<"s1不为空"<<endl;
		cout<<s1.size()<<endl;
	}
} 

//交换
void test02(){
		set<int> s1;
	
	//插入数据
	s1.insert(10);
	s1.insert(20);
	s1.insert(40);
	s1.insert(30);
	
		set<int> s2;
	
	//插入数据
	s2.insert(100);
	s2.insert(200);
	s2.insert(400);
	s2.insert(300);
	
	cout<<"交换前"<<endl;
	printSet(s1);
	printSet(s2);
	
	cout<<"交换前"<<endl;
	s1.swap(s2);
	printSet(s1);
	printSet(s2);
} 
int main()
{
//	test01();
test02();
	system("pause");
}

map

#include <map>
 #include <iostream>
#include <vector>
#include<string>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<set>
#include<map>
using namespace std;
void printMap(map<int,int>&m)
{
for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
{
cout << "key = " << it->first << " value = " << it->second << endl;
}
cout << endl;
}
void test01()
{
map<int, int>m;
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 20));
m.insert(pair<int, int>(3, 30));
if (m.empty())
{
cout << "m为空" << endl;
}
else
{
cout << "m不为空" << endl;
cout << "m的大小为： " << m.size() << endl;
}
}
//交换
void test02()
{
map<int, int>m;
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 20));
m.insert(pair<int, int>(3, 30));
map<int, int>m2;
m2.insert(pair<int, int>(4, 100));
m2.insert(pair<int, int>(5, 200));
m2.insert(pair<int, int>(6, 300));
cout << "交换前" << endl;
printMap(m);
printMap(m2);
cout << "交换后" << endl;
m.swap(m2);

printMap(m);
printMap(m2);
}
int main() {
test01();
test02();
system("pause");
return 0;
}

set和map****插入和删除

功能描述：
t 容器进行插入数据和删除数据
函数原型：
insert(elem) ; // 在容器中插入元素。
clear() ; // 清除所有元素
erase(pos) ; // 删除 pos 迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end) ; // 删除区间 [beg,end) 的所有元素 ，返回下一个元素的迭代器。
erase(key) ; // 删除容器中值为 key 的元素

set

#include <iostream>
#include <vector>
#include<string>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<set>
using namespace std;
void printSet(set<int> &s){
	for(set<int>::iterator it=s.begin();it!=s.end();it++){
		cout<<*it<<" ";
	}
	cout<<endl;
}
void test01(){
	set<int>s1;
	
	//插入
	s1.insert(10);
	s1.insert(20);
	s1.insert(40);
	s1.insert(30);
//	s1.insert(2,90);//想在第二位插29,报错 
	//遍历
	printSet(s1); 
	
	//删除
//	s1.erase(s1.begin());
	//删除的是排序后的首位
	
	//删除重载版本
	s1.erase(30);//直接把30删除了    和list  remove一样 
	printSet(s1); 
	//清空 
	s1.erase(s1.begin(),s1.end());
	printSet(s1);
	
	s1.clear(); 
} 
int main()
{
	test01();
	system("pause");
}

map

#include <iostream>
#include <vector>
#include<string>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<set>
#include<map>
using namespace std;
void printMap(map<int,int>&m){
	for(map<int,int>::iterator it=m.begin();it!=m.end();it++){
		cout<<"key值="<<(*it).first<<"value="<<it->second<<endl;//打印两个值		两种表达方式都可以 
	}
	cout<<endl;
}
void test01(){
	map<int,int>m;
	
	//插入
	//第一种
	m.insert(pair<int,int>(1,10));
	
	//第二种
	m.insert(make_pair(2,20));
	
	//第三种
	m.insert(map<int,int>::value_type(3,30));
	
	//第四种	不建议用,用途 可以利用key访问到value 
	 
	m[4]=40;
/*例如*/	cout<<m[4]<<endl;//访问 
//	cout<<m[5]<<endl;直接可将value默认为零 
	printMap(m);
	
	
	//删除
	m.erase(m.begin()) ;
	printMap(m);
	
	m.erase(3);//删了key为3的数值  按照key删除 
	printMap(m); 
	
//	m.erase(m.begin(),m.end());
	m.clear();
	printMap(m);
	
	
} 
int main()
{
	test01();
	system("pause");
}

map和set****查找和统计

功能描述：
对 map 容器进行查找数据以及统计数据
函数原型：
find(key) ; // 查找 key 是否存在 , 若存在，返回该键的元素的迭代器；若不存在，返回 set.end();
count(key) ; // 统计 key 的元素个数

set

#include <iostream>
#include <vector>
#include<string>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<set>
using namespace std;
void test01(){
	set<int> s1;
	
	//插入数据
	s1.insert(10);
	s1.insert(20);
	s1.insert(40);
	s1.insert(30);	
	
	set<int>::iterator pos=s1.find(30);//find找到返回it的那个数值，没找到返回it.end() 
	if(pos!=s1.end()){
		cout<<"找到元素"<<*pos<<endl;
	}
	else{
		cout<<"未找到元素"<<endl;
	}
} 

void test02(){
	set<int> s1;
	s1.insert(10);
	s1.insert(20);
	s1.insert(40);
	s1.insert(30);
	
	//统计30的个数 
	int num=s1.count(30);
	cout<<"num="<<num<<endl;//1
	
	int numq=s1.count(300);
	cout<<"numq="<<numq<<endl;//0
}
int main()
{
//	test01();
	test02();
	system("pause");
}

map

#include <iostream>
#include <vector>
#include<string>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<set>
#include<map>
using namespace std;
void test01()
{
map<int, int>m;
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 20));
m.insert(pair<int, int>(3, 30));
//查找
map<int, int>::iterator pos = m.find(3);
if (pos != m.end())
{
cout << "找到了元素 key = " << (*pos).first << " value = " << (*pos).second << endl;
}
else
{
cout << "未找到元素" << endl;
}
//统计
int num = m.count(3);
cout << "num = " << num << endl;//map只有1 
}
int main()
{
	test01();
	system("pause");
}

set和map容器排序

默认 从小到大排序，掌握如何改变排序规则
主要技术点 :
利用仿函数，可以改变排序规则

set

#include <iostream>
#include <vector>
#include<string>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<set>
//set内置类型指定排序规则 
using namespace std;
//仿函数 
class MyCompare{
	public:
		bool operator()(int v1,int v2)//第一个小括号表示重载符号,第二个小括号表示函数的参数列表 
		{
			return v1>v2;//降序排列 
		}
	
};

void test01(){
	set<int> s1;
	
	s1.insert(10);
	s1.insert(40);
	s1.insert(20);
	s1.insert(50);
	s1.insert(30);
	for(set<int>::iterator it=s1.begin();it!=s1.end();it++){
		cout<<*it<<" ";//默认排序了 
	}
	cout<<endl;
	
	//指定排序规则为从大到小
	set<int,MyCompare> s2;//按照仿函数类型插入 
	
	s2.insert(10);//插的时候已经改变不了了,所以要在插之前改变属性 
	s2.insert(40);
	s2.insert(20);
	s2.insert(50);
	s2.insert(30);
	
	for(set<int,MyCompare>::iterator it=s2.begin();it!=s2.end();it++){
		cout<<*it<<" ";//逆序 
	}
	cout<<endl;
} 
int main()
{
	test01();
	system("pause");
}

set自定义排序

#include <iostream>
#include <vector>
#include<string>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<set>
using namespace std;

class Person
{
	public:
		Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
		string m_Name;
		int m_Age;
};
class comparePerson
{
public:
	bool operator()(const Person &p1, const Person &p2)//这里加不加&都可,值传递或者引用传递 
{
//按照年龄进行排序 降序
	return p1.m_Age > p2.m_Age;
}
};
void test01(){
	//自定义数据类型 都会指定排序规则 
	set<Person, comparePerson> s;
	Person p1("刘备", 23);
	Person p2("关羽", 28);
	Person p3("张飞", 25);
	Person p4("赵云", 21);
	s.insert(p1);
	s.insert(p2);
	s.insert(p3);
	s.insert(p4);

for (set<Person, comparePerson>::iterator it = s.begin(); it != s.end(); it++)
{
cout << "姓名： " << it->m_Name << " 年龄： " << it->m_Age << endl;
}
	
	
} 
int main()
{
	test01();
	system("pause");
}

map

#include <iostream>
#include <vector>
#include<string>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<set>
#include<map>
using namespace std;
//仿函数 
class MyCompare{//仿函数使其从大到小排序 
	public:
		bool operator()(int v1,int v2){
			//降序
			return v1>v2; 
		}
};

void test01(){
	map<int,int,MyCompare>m;//改变排序顺序,要从这一步入手 
	//然后就是逆序输出 
	
	m.insert(make_pair(1,10));
	m.insert(make_pair(3,30));
	m.insert(make_pair(2,20));
	m.insert(make_pair(4,40));//默认用key排序   
	
	
	for(map<int,int,MyCompare>::iterator it=m.begin();it!=m.end();it++){
		cout<<"key值="<<(*it).first<<"value="<<it->second<<endl;//打印两个值		两种表达方式都可以 
	}
	cout<<endl;

} 
int main()
{
	test01();
	system("pause");
}

set和map与multimap区别

set 不可以插入重复数据，而 multiset 可以
set 插入数据的同时会返回插入结果，表示插入是否成功
multiset 不会检测数据，因此可以插入重复数据
map 和 multimap 区别 ：
map 不允许容器中有重复 key 值元素
multimap 允许容器中有重复 key 值元素

#include <iostream>
#include <vector>
#include<string>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<set>

using namespace std;
void test01(){
	set<int>s;
	pair<set<int>::iterator,bool> ret=	s.insert(10);
	if(ret.second){
		cout<<"第一次插入成功"<<endl;//执行 
	}
	else{
		cout<<"第一次插入失败"<<endl;
	}
	
	ret=s.insert(10);
		if(ret.second){
		cout<<"第二次插入成功"<<endl;
	}
	else{
		cout<<"第二次插入失败"<<endl;//执行 
	}
	
	multiset<int>ms;
	//允许插入重复的值
	ms.insert(10); 
	ms.insert(10);
	for(multiset<int>::iterator it=ms.begin();it!=ms.end();it++){
		cout<<*it<<" ";//10 10 说明允许重复 
	}
	cout<<endl;
	
} 
int main()
{
	test01();
	system("pause");
}

pair对组创建

#include <iostream>
#include <vector>
#include<string>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<set>
using namespace std;
//成队出现的数据，利用对组可以返回两个数据
 

void test01(){
	//第一种创建
	pair<string,int>p("Tom",20);
	cout<<"姓名"<<p.first<<"年龄"<<p.second<<endl;
	
	//第二种方式
	pair<string,int>p2=make_pair("jerry",30);
	cout<<"姓名"<<p2.first<<"年龄"<<p2.second<<endl; 
} 
int main()
{
	test01();
	system("pause");
}