集合set/multiset容器部分API总结

1.set容器是一种关联式容器，在插入数据时会根据键值进行排序，不允许出现重复的键值。
2.set容器不能通过迭代器来修改键值，其迭代器不支持随机访问.
3.multiset允许键值重复
#include<iostream>
#include<set>       //set 或 multiset
#include<string>
using namespace std;

//关联式容器：在插入数据时会按照键值大小顺序对元素进行排序，排序后的序列为最终的容器元素系列
//集合set特性：1.所有元素都会根据元素的键值自动被排序，set容器不允许出现的键值.
//2.set容器不可以通过迭代器来改变元素的值，因为如果改变了值，那么就不一定是有序的系列,破坏了set容器的组织，也就是说set的迭代器是一种const_iterator
//3.set的迭代器不支持随机访问,set的键值(key)就是实值(value)
//multiset和set的区别在于multiset允许键值重复


void printSet(set<int>& s) {
	
	if (s.empty())
	{
		cout << "set is empty" << endl;
		return;
	}
	cout << "set elem: ";
	for (set<int>::iterator it = s.begin(); it != s.end(); it++)
		cout << *it << " ";
	cout << endl;
}
//初始化和赋值
void test_one() {

	set<int> s1;
	
	s1.insert(2);         //插入元素
	s1.insert(-6);
	s1.insert(0);
	s1.insert(99);
	s1.insert(-100);

	printSet(s1);         //-100 -6 0 2 99

	set<int> s2(s1);      //拷贝构造函数
	set<int> s3 = s1;    //重载 =

	s1.swap(s2);         //交换两个set容器

	if (s1.empty())
		cout << "set is empty" << endl;
	else
		cout << "set size : " << s1.size() << endl;
}

//插入和删除
void test_two() {

	set<int> s1;

	//插入元素
	s1.insert(-100);
	s1.insert(2);        
	s1.insert(-6);
	s1.insert(0);
	s1.insert(99);
	s1.insert(-100);      //set容器中重复的键值不会再插入
	printSet(s1);
	
	//删除元素
	s1.erase(-100);         //1.(elem) 删除set容器里值为-100的元素
	printSet(s1);
	s1.erase(s1.begin());   //2.(pos) 删除指定的迭代器位置的元素
	printSet(s1);
	s1.erase(s1.begin(), s1.end());  //3.(start,end) :删除区间[start,end)的所有数据
	printSet(s1);
}

//查找
void test_three() {

	set<int> s;

	s.insert(10);
	s.insert(7);
	s.insert(5);
	s.insert(3);
	s.insert(0);
	printSet(s);

	//find(key)查找元素，查找成功返回该元素对应的迭代器，查找失败返回set.end()
	set<int>::iterator pos = s.find(3);
	if (pos != s.end())
		cout << "find succeed, value = " << *pos << endl;
	else cout << "no find" << endl;

	//count(key)查找key在集合中的个数,在set容器里返回值只有1和0，因为set不会出现重复的元素
	int num  (s.count(7));
	cout << "7 count : " << num << endl;
	num = s.count(-1);
	cout << "-1 count : " << num << endl;

	//lower_bound(elem)查找容器里第一个大于等于给定值elem的元素，成功则返回第一个元素的迭代器，失败返回set.end()
	set<int>::iterator lower(s.lower_bound(7));
	if (lower != s.end())
		cout << "找到容器里第一个大于等于 7 的元素，该元素为： " << *lower << endl;
	else  cout << "no find" << endl;

	//upper_bound(elem) 查找第一个大于elem的元素
	set<int>::iterator upper = s.upper_bound(7);
	if(upper!=s.end())
		cout << "找到容器里第一个大于 7 的元素，该元素为： " << *upper << endl;
	else  cout << "no find" << endl;

	//equal_range(elem)能同时实现lower_bound()和upper_bound()，返回值为集合中与给定值elem相等的上下限(a<=elem<b),用对组来接收上下限
	pair<set<int>::iterator,set<int>::iterator> range = s.equal_range(7);
	if (range.first != s.end())
		cout << "找到下限为： " << *range.first << endl;
	else cout << "no find" << endl;
	if (range.second != s.end())
		cout << "找到上限为： " << *range.second << endl;
	else cout << "no find" << endl;
}
/*-------------------------------------------------------------------------------*/

//对组pair:对组中的两个元素的数据类型可以一样，也可以不一样
void test_pair() {

	pair<string, int> p1((string)"prim", 23);         //1,使用拷贝构造方式创建
	
	cout << "name : " << p1.first << "   ";           //获取对组中的第一个元素
	cout << "age : " << p1.second << endl;            //获取对组中的第二个元素

	pair<string, int> p2 = make_pair("binary", 22);  //2.使用make_pair方式创建对组

	cout << "name : " << p2.first << "   ";
	cout << "age : " << p2.second << endl;

	p2.swap(p1);                                     //交换两个拥有相同数据类型的对组
	cout << "name : " << p2.first << "   ";
	cout << "age : " << p2.second << endl;

	pair<string, int> p3 = p1;                       //3.重载 =
	cout << "name : " << p3.first << "   ";
	cout << "age : " << p3.second << endl;
}
/*-----------------------------------------------------------------------------------*/

//测试set.insert，判断集合set能不能出现重复键值
//插入函数的返回值是对组数据类型，pair<iterator,bool>, 对组的第一个元素为一个迭代器，第二个元素为bool类型
void test_insert() {

	set<int> s;
	pair<set<int>::iterator, bool> res;

	res = s.insert(100);
	if (res.second)
		cout << "insert sucess" << endl;
	else
		cout << "insert fail" << endl;

	res = s.insert(100);
	if (res.second)
		cout << "insert sucess" << endl;
	else
		cout << "insert fail" << endl;
	printSet(s);
		
	/*
		insert sucess
		insert fail
		set elem : 100
	*/

	//multiset可以实现在集合中有重复元素
	multiset<double> s2;
	s2.insert(333.99);
	s2.insert(333.99);
	for (multiset<double>::iterator it = s2.begin(); it != s2.end(); it++)
		cout << *it << " ";
	cout << "\n";
	//333.99 333.99
}

//set排序：必须在插入数据前就进设置排序规则
//默认的规则是升序排序，如果要设置为降序排序，就要使用仿函数
//使用仿函数的方法:重载 ()
class myCompare
{
public :
	//重载 () 实现仿函数
	bool operator() (int a, int b) { 
		return a > b ? true : false;    //设置为降序排序
	}
};

void test_sort() {

	set<int, myCompare> s;     //第二个类型为拥有仿函数的类

	s.insert(1);
	s.insert(2);
	s.insert(3);
	s.insert(4);
	s.insert(5);
	for (set<int, myCompare>::iterator it = s.begin(); it != s.end(); it++) {
		cout << *it << "  ";
	}
	cout << "\n";
}

//集合与自定义数据类型
//自定义数据类似放入集合时，必须使用仿函数指定排序规则
class myclass
{
public:

	myclass(string name, int age) {
		this->m_age = age;
		this->m_name = name;
	}	

public:
	string m_name;
	int m_age;
};

class MyCompareClass
{
public :

	bool operator() ( myclass s1, myclass s2) {
		return s1.m_age > s2.m_age;                //指定排序规则为降序
	}
};

void test_four() {

	set<myclass, MyCompareClass> s;

	myclass p1("李白", 100);
	myclass p2("杜甫", 90);
	myclass p3("苏轼", 110);

	s.insert(p1);
	s.insert(p2);
	s.insert(p3);

	for (set<myclass>::iterator it = s.begin(); it != s.end(); it++)
		cout << "name: " << it->m_name << "  age: " << (*it).m_age << endl;
}

int main()
{
	//test_one();
	//test_two();
	//test_three();
	//test_pair();
	//test_insert();
	//test_sort();
	test_four();

	cin.get();
	return 0;
}
集合set/multiset容器部分API总结

猜你喜欢
