容器set(构造和赋值,大小和交换,插入和删除,查找和统计,set和multiset区别,pari队组的创建,内置数据类型排序规则,自定义数据类型指定排序规则)

#define _CRT_SECURE_NO_WARNINGS 1
#include<set>	//不管是set还是multiset都是用set
#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<string>
using namespace std;

//set/multiset容器
//简介
// 所有元素都会在插入时自动被排序
//本质
// set/multiset属于关联式容器,底层结构是用二叉树 - (红黑树)
//set和multiset区别
// set不允许容器中有重复的元素
// multiset允许容器中有重复的元素
//set构造和赋值
// set<T> st;	//默认构造函数
// set(const set &st);	//拷贝构造函数
//赋值
// set& operator=(const set &st);	//重载等号操作符
//
//总结:
// set容器插入数据时用insert
// set容器插入数据的数据会自动排序
//

//set容器遍历
//typedef int dataType;
//void printSet(set<dataType>& s)
//{
//	for (set<dataType>::iterator it = s.begin(); it != s.end(); it++)
//	{
//		cout << (*it) << " ";
//	}
//
//	cout << endl;
//}
//
//void test01()
//{
//	set<dataType>s1;
//
//	//插入数据 只有insert方式
//	s1.insert(20);
//	s1.insert(40);
//	s1.insert(10);
//	s1.insert(40);
//	s1.insert(30);
//
//	//遍历容器
//	//ste容器特点: 所有元素插入的时候会自动被排序
//	//set容器不允许插入重复的值
//	printSet(s1);
//
//	//拷贝构造
//	set<int>s2(s1);
//	printSet(s2);
//
//	//赋值
//	set<int>s3;
//	s3 = s2;
//	printSet(s3);
//
//}
//
//int main()
//{
//	test01();
//
//	system("pause");
//	return 0;
//}

//set大小操作 - 统计set容器大小以及交换set容器
// 函数原型
// size();	//返回容器中元素的个数
// empty();	//判断容器是否为空
// swap(st);	//交换两个合计容器
//
//总结
// 统计大小 - size
// 判断是否为空 - empty
// 交换容器 - swap
//

//set容器 大小和交换
//typedef int dataType;
//void printSet(set<dataType>& s)
//{
//	for (set<dataType>::iterator it = s.begin(); it != s.end(); it++)
//	{
//		cout << (*it) << " ";
//	}
//
//	cout << endl;
//}
//
////大小
//void test01()
//{
//	set<dataType>s1;
//	//插入数据
//	s1.insert(10);
//	s1.insert(20);
//	s1.insert(30);
//	s1.insert(40);
//
//	//打印函数
//	printSet(s1);
//
//	//判断是否为空
//	if (s1.empty())
//	{
//		cout << "空" << endl;
//	}
//	else
//	{
//		cout << "不空" << endl;
//		cout << "大小 = " << s1.size() << endl;
//	}
//}
//
////交换
//void test02()
//{
//	set<dataType>s1;
//	//插入数据
//	s1.insert(10);
//	s1.insert(20);
//	s1.insert(30);
//	s1.insert(40);
//
//	set<dataType>s2;
//	s2.insert(100);
//	s2.insert(200);
//	s2.insert(300);
//	s2.insert(400);
//
//	cout << "交换前" << endl;
//	printSet(s1);
//	printSet(s2);
//
//	cout << "交换后" << endl;
//	s1.swap(s2);
//	printSet(s1);
//	printSet(s2);
//
//}
//int main()
//{
//	test01();
//	test02();
//
//	system("pause");
//	return 0;
//}

//set插入和删除 - set容器进行插入数据和删除数据
//函数原型
// insert(elem);	//在容器中插入数据
// clear();	//清除所有元素
// erase(pos);	//删除pos迭代器所指的元素,返回下一个元素的迭代器
// erase(beg,end);	//删除区间beg,end的所有元素,返回下一个元素的迭代器
// erase(elem);	//删除容器中值为elem的元素
//总结
// 插入 - insert
// 删除 - erase
// 清空 - clear

//typedef int dataType;
//void printSet(set<dataType>& s)
//{
//	for (set<dataType>::iterator it = s.begin(); it != s.end(); it++)
//	{
//		cout << (*it) << " ";
//	}
//
//	cout << endl;
//}
//
//void test01()
//{
//	set<dataType>s1;
//
//	//插入数据 只有insert方式
//	s1.insert(20);
//	s1.insert(40);
//	s1.insert(10);
//	s1.insert(40);
//	s1.insert(30);
//
//	//遍历容器
//	printSet(s1);
//
//	//删除 删除是删除已经排序好的序列了
//	s1.erase(s1.begin());
//	printSet(s1);
//
//	//删除重载版本
//	s1.erase(40);
//	printSet(s1);
//
//	//清空
//	//s1.erase(s1.begin(), s1.end());
//	s1.clear();
//	printSet(s1);
//
//}
//
//int main()
//{
//	test01();
//
//	system("pause");
//	return 0;
//}

//set查找和统计 - 对set容器进行查找数据以及统计数据
//函数原型
// find(key);	//查找key是否存在,在返回该元素的迭代器,不在返回set.end();
// count(key);	//统计可以的元素个数 (对于set容器而言无非是0或1, 对于multiset而言可能会大于1)
//总结
// 如果不允许插入重复数据可以利用set
// 如果需要插入重复数据利用multiset

//typedef int dataType;
//void printSet(set<dataType>& s)
//{
//	for (set<dataType>::iterator it = s.begin(); it != s.end(); it++)
//	{
//		cout << (*it) << " ";
//	}
//
//	cout << endl;
//}
//
//void test01()
//{
//	set<dataType>s1;
//
//	//插入数据 只有insert方式
//	s1.insert(20);
//	s1.insert(40);
//	s1.insert(10);
//	s1.insert(40);
//	s1.insert(30);
//
//	//遍历容器
//	printSet(s1);
//
//	//查找
//	set<dataType>::iterator pos =  s1.find(400);
//	//判断
//	if (pos != s1.end())
//	{
//		cout << "找到 = " << *pos << endl;
//	}
//	else
//	{
//		cout << "未找到" << endl;
//	}
//}
//
////统计
//void test02()
//{
//	set<dataType>s1;
//
//	//插入数据 只有insert方式
//	s1.insert(20);
//	s1.insert(40);
//	s1.insert(10);
//	s1.insert(40);
//	s1.insert(30);
//
//	//遍历容器
//	printSet(s1);
//
//	//统计个数
//	int num = s1.count(40);
//	//对于set而言统计的结果要么是0,要么是1
//	cout << num << endl;
//
//}
//
//int main()
//{
//	test01();
//	test02();
//
//	system("pause");
//	return 0;
//}

//set和multiset区别 - 掌握set和multiset区别
//区别
// set不可以插入重复数据,而multiset可以
// set插入数据的同时会返回插入结果,表示插入是否成功
// multiset不会检测数据,因此可以插入重复数据
//总结
// 如果不允许插入重复数据可以利用set
// 如果需要插入重复数据利用multiset

//typedef int dataType;
//void test01()
//{
//	set<dataType>s1;
//
//	//插入数据 只有insert方式
//	//队组pair在定义中可以找到
//	pair<set<dataType>::iterator, bool>ret = s1.insert(10);//定义中返回的类型是pair
//	if (ret.second)
//	{
//		cout << "第一次插入成功" << endl;
//	}
//	else
//	{
//		cout << "失败" << endl;
//	}
//
//	//插入重复的值
//	ret = s1.insert(10);
//	if (ret.second)
//	{
//		cout << "第二次插入成功" << endl;
//	}
//	else
//	{
//		cout << "第二次失败" << endl;
//	}
//
//	//允许插入重复值
//	multiset<dataType>ms;
//	ms.insert(10);//返回的类型是迭代器
//	ms.insert(10);
//	
//	for (multiset<dataType>::iterator it = ms.begin(); it != ms.end(); it++)
//	{
//		cout << *it << " ";
//	}
//	cout << endl;
//
//}
//
//int main()
//{
//	test01();
//
//	system("pause");
//	return 0;
//}

//pair队组创建 - 成对出现的数据,利用队组可以返回两个数据
// 两种创建方式
// pair<type, type> p(value1,value2);
// pair<type, type> p = make_pair(value1,value2);
//总结
// 两种方式都可以创建队组,记住一种即可

//typedef int dataType;
//void test01()
//{
//	//第一种
//	pair<string, int>p("Tom", 20);
//	cout << "姓名 = " << p.first << "\t年龄 = " << p.second << endl;
//
//	//第二种
//	pair<string, int>p2 = make_pair("Jerry", 30);
//	cout << "姓名 = " << p2.first << "\t年龄 = " << p2.second << endl;
//
//}
//
//int main()
//{
//	test01();
//
//	system("pause");
//	return 0;
//}

//set容器排序 - set容器默认排序为从小到大,掌握如何改变排序规则
//主要技术点
// 利用仿函数,可以改变排序规则
//总结
// 1.利用仿函数可以指定set容器的排序规则(仿函数本质是个类型, 记得后面加const - this指针不可更改)
// 2.对于自定义数据类型,set必须指定排序规则才可以插入数据(还是需要仿函数,但是都需要加const函数列表需要,后面还需要加const) 

//typedef int dataType;
//class MyCompare
//{
//public:
//	bool operator()(dataType v1, dataType v2) const
//	{
//		return v1 > v2;
//	}
//};
//
////1.set存放内置的数据类型
//void printSet(set<dataType>& s)
//{
//	for (set<dataType>::iterator it = s.begin(); it != s.end(); it++)
//	{
//		cout << (*it) << " ";
//	}
//
//	cout << endl;
//}
//
//void test01()
//{
//	set<dataType>s1;
//
//	//插入数据 只有insert方式,数据插入完也就是排序完了,所以一开始告诉编译器
//	s1.insert(20);
//	s1.insert(40);
//	s1.insert(10);
//	s1.insert(50);
//	s1.insert(30);
//
//	//遍历容器
//	printSet(s1);
//
//	//指定排序规则从大到小,因为s1已经插入排序完了,所以用s2
//	set<dataType,MyCompare>s2;
//
//	//插入数据 只有insert方式,数据插入完也就是排序完了,所以一开始告诉编译器
//	s2.insert(20);
//	s2.insert(40);
//	s2.insert(10);
//	s2.insert(50);
//	s2.insert(30);
//	for (set<dataType>::iterator it = s2.begin(); it != s2.end(); it++)
//	{
//		cout << *it << " ";
//	}
//	cout << endl;
//}
//
//int main()
//{
//	test01();
//
//	system("pause");
//	return 0;
//}

//2.set存放自定义的数据类型
typedef int dataType;
class Person
{
public:
	Person(string name, int age);
	~Person();
	string m_Name;
	int m_Age;
};

Person::Person(string name, int age)
{
	this->m_Name = name;
	this->m_Age = age;
}

Person::~Person()
{
}

class comparePerson
{
public:
	bool operator()(const Person& p1, const Person& p2) const
	{
		//年龄降序
		return p1.m_Age > p2.m_Age;
	}

};

void printSet(set<Person, comparePerson>& s)
{
	for (set<Person, comparePerson>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << "姓名 = " << it->m_Name << "\t年龄 = " << it->m_Age << endl;
	}
}

void test01()
{
	//自定义数据类型,都会指定排序规则(用到仿函数)
	set<Person, comparePerson>s1;

	//插入数据 只有insert方式
	Person p1("小黑", 20);
	Person p2("小白", 25);
	Person p3("小绿", 22);
	Person p4("小灰", 21);

	//插入的时候会排序,但是它不知道怎么排序
	s1.insert(p1);
	s1.insert(p2);
	s1.insert(p3);
	s1.insert(p4);

	//遍历容器
	printSet(s1);

}

int main()
{
	test01();

	system("pause");
	return 0;
}