《STL》— set集合容器

                                       set集合容器         

         set集合容器实现了红黑树（Red-Black Tree）的平衡二叉检索树的的数据结构，在插入元素时，它会自动调整二叉树的排列，把该元素放到适当的位置，以确保每个子树根节点的键值大于左子树所有节点的键值，而小于右子树所有节点的键值；另外，还得确保根节点的左子树的高度与有字数的高度相等，这样，二叉树的高度最小，从而检索速度最快。要注意的是，它不会重复插入相同键值的元素，而采取忽略处理。

        平衡二叉检索树的检索使用中序遍历算法，检索效率高于vector、deque、和list的容器。另外，采用中序遍历算法可将键值由小到大遍历出来，所以，可以理解为平衡二叉检索树在插入元素时，就会自动将元素按键值从小到大的顺序排列。

        构造set集合的主要目的是为了快速检索，使用set前，需要在程序头文件中包含声明“#include<set>”。

1.创建set集合对象

 

#include <set>
using namespace std;
int main(int argc, char* argv[])
{
	//定义元素类型为int的集合对象s,当然没有任何元素
	//元素的排列采用默认的比较规则，当然，可以自定义比较规则函数
	set<int> s;
	return 0;
}

2.元素的插入与中序遍历
采用insert()方法把元素插入到集合中去,插入的默认规则是从小到大，也可自定义，使用前向迭代器对集合中序遍历，其结果正好是元素排序的结果。

 

 

#include <set>
#include <iostream>
using namespace std;
int main(int argc, char* argv[])
{
	//定义元素类型为int的集合对象s,当前没有任何元素 
	set<int> s;
	//插入了5个元素,但由于8有重复,第二次插入的8的并没有执行 
	s.insert(8);//第一次插入8，可以插入 
	s.insert(1);
	s.insert(12);
	s.insert(6);
	s.insert(8);//第二次插入8,重复元素，不会插入 
	//中序遍历集合中的元素 
	set<int>::iterator it;//定义前向迭代器 
	//中序遍历集合中的所有元素 
	for(it=s.begin();it!=s.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;//回车换行 
	return 0;
}
运行结果：
1 6 8 12

3.元素的反向遍历
使用反向迭代器reverse_iterator可以反向遍历集合,输出的结果正好是集合元素的反向排序的结果。
它需要用到rbegin()和rend()方法

 

 

#include <set>
#include <iostream>
using namespace std;
int main(int argc, char* argv[])
{
	//定义元素类型为int得集合对象s,当前没有任何元素 
	set<int> s;
	//插入了5个元素，但由于8有重复，第二次插入得8并没有执行 
	s.insert(8);
	s.insert(1);
	s.insert(12);
	s.insert(6);
	s.insert(8);
	//反向遍历集合中的元素 
	set<int>::reverse_iterator rit;//定义反向迭代器 
	for(rit=s.rbegin();rit!=s.rend();rit++)
	{
		cout<<*rit<<" ";
	}
 	cout<<endl;//回车换行 
	return 0;
}
运行结果：12 8 6 1 

4.元素的删除
与插入元素的处理一样，集合具有高效的删除功能，并自动调整内部的红黑树的平衡
删除的对象可以是某一个迭代器位置上的元素、等于某键值的元素、一个区间上的元素和清空集合

#include <set>
#include <iostream>
using namespace std;
int main(int argc, char* argv[])
{
	//定义元素类型为int集合类型s,当前没有任何元素 
	set<int> s;
	//插入了5个元素，但由于8有重复，第二次插入的8并没有执行 
	s.insert(8);
	s.insert(1);
	s.insert(12);
	s.insert(6);
	s.insert(8);
	//删除键值为6的元素 
	s.erase(6);
	//反向遍历集合中的元素
	set<int>::reverse_iterator rit;//定义反向迭代器 
	for(rit=s.rbegin();rit!=s.rend();rit++)
	{
		cout<<*rit<<" ";
	}
	cout<<endl;//回车换行 
	//清空集合 
	s.clear();
	//输出集合的大小，为0 
	cout<<s.size()<<endl;
	return 0;
}
运行结果：
12 8 1
0

5.元素的检索
使用find()方法对集合进行搜索,如果找到查找的键值，则返回该键值的迭代器位置 ，否则，返回集合最后一个元素后面的一个位置，即end()

 

 

#include <set>
#include <iostream>
using namespace std;
int main(int argc, char* argv[])
{
	set<int> s;
	s.insert(8);
	s.insert(1);
	s.insert(12);
	s.insert(6);
	s.insert(8);
	set<int>::iterator it; //定义前向迭代器 
	//查找键值为6的元素 
	it=s.find(6);
	if(it!=s.end())//找到 
		cout<<*it<<endl;
	else//没找到 
		cout<<"not find it"<<endl;
	//查找键值为20的元素 
	it=s.find(20);
	if(it!=s.end())//找到 
		cout<<*it<<endl;
	else//没找到 
		cout<<"not find it"<<endl;
	return 0;
}
运行结果
6 
not find it 

6.自定义比较函数
使用insert()将元素插入到集合中去的时候，集合会根据设定的比较函数将该元素放到该放的节点上去。在定义集合的时候，如果没有指定比较函数,那么采取默认的 比较函数，即按键值由小到大的顺序插入元素

 

 

(1)如果元素不是结构体，那么，可以编写比较函数
#include <set>
#include <iostream>
using namespace std;
//自定义比较函数myComp,重载()操作符 
struct myComp
{
	bool operator()(const int &a,const int &b)
	{
		if(a!=b)
			return a>b;
		else
			return a>b;
	}
};

int main(int argc, char* argv[])
{
	//定义元素类型为int的集合对象s,当前没有任何元素 
	//采用比较函数myComp
	set<int,myComp> s;
	s.insert(8);
	s.insert(1);
	s.insert(12);
	s.insert(6);
	s.insert(8);
	set<int,myComp>::iterator it;//定义前向迭代器 
	for(it=s.begin();it!=s.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
	return 0;
}
运行结果
12 8 6 1 
(2)如果元素是结构体,那么,可以直接把比较函数写在结构体内。
#include <set>
#include <string>
#include <iostream>
using namespace std;
struct Info
{
	string name;
	float score;
	//重载运算符"<"操作符，自定义排序规则 
	bool operator < (const Info &a) const
	{
		//按sccore由大到小排列。如果要从小到大使用>即可 
		return a.score<score;
	}
};
int main(int argc, char* argv[])
{
	定义元素类型为Info结构体的集合对象s,当前没有任何元素 
	set<Info> s;
	//定义Info类型的元素 
	Info info;
	//插入3个元素 
	info.name="Jack";
	info.score=80.5;
	s.insert(info);
	info.name="Tomi";
	info.score=20.5;
	s.insert(info);
	info.name="Nacy";
	info.score=60.5;
	s.insert(info);
	set<Info>::iterator it;//定义迭代器 
	for(it=s.begin();it!=s.end();it++)
	{
		cout<<(*it).name<<" : "<<(*it).score<<endl;
	}
	return 0;
} 
运行结果：
Jack : 80.5
Nacy : 60.5
Tomi : 20.5
 

全部代码：

 

 

1.创建set集合对象
#include <set>
using namespace std;
int main(int argc, char* argv[])
{
	//定义元素类型为int的集合对象s,当然没有任何元素
	//元素的排列采用默认的比较规则，当然，可以自定义比较规则函数
	set<int> s;
	return 0;
}
2.元素的插入与中序遍历
采用insert()方法把元素插入到集合中去,插入的默认规则是从小到大，也可自定义
使用前向迭代器对集合中序遍历，其结果正好是元素排序的结果。

#include <set>
#include <iostream>
using namespace std;
int main(int argc, char* argv[])
{
	//定义元素类型为int的集合对象s,当前没有任何元素 
	set<int> s;
	//插入了5个元素,但由于8有重复,第二次插入的8的并没有执行 
	s.insert(8);//第一次插入8，可以插入 
	s.insert(1);
	s.insert(12);
	s.insert(6);
	s.insert(8);//第二次插入8,重复元素，不会插入 
	//中序遍历集合中的元素 
	set<int>::iterator it;//定义前向迭代器 
	//中序遍历集合中的所有元素 
	for(it=s.begin();it!=s.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;//回车换行 
	return 0;
}
运行结果：
1 6 8 12
3.元素的反向遍历
使用反向迭代器reverse_iterator可以反向遍历集合,输出的结果正好是集合元素的反向排序的结果。
它需要用到rbegin()和rend()方法

#include <set>
#include <iostream>
using namespace std;
int main(int argc, char* argv[])
{
	//定义元素类型为int得集合对象s,当前没有任何元素 
	set<int> s;
	//插入了5个元素，但由于8有重复，第二次插入得8并没有执行 
	s.insert(8);
	s.insert(1);
	s.insert(12);
	s.insert(6);
	s.insert(8);
	//反向遍历集合中的元素 
	set<int>::reverse_iterator rit;//定义反向迭代器 
	for(rit=s.rbegin();rit!=s.rend();rit++)
	{
		cout<<*rit<<" ";
	}
 	cout<<endl;//回车换行 
	return 0;
}
运行结果：12 8 6 1 
4.元素的删除
与插入元素的处理一样，集合具有高效的删除功能，并自动调整内部的红黑树的平衡
删除的对象可以是某一个迭代器位置上的元素、等于某键值的元素、一个区间上的元素和清空集合

#include <set>
#include <iostream>
using namespace std;
int main(int argc, char* argv[])
{
	//定义元素类型为int集合类型s,当前没有任何元素 
	set<int> s;
	//插入了5个元素，但由于8有重复，第二次插入的8并没有执行 
	s.insert(8);
	s.insert(1);
	s.insert(12);
	s.insert(6);
	s.insert(8);
	//删除键值为6的元素 
	s.erase(6);
	//反向遍历集合中的元素
	set<int>::reverse_iterator rit;//定义反向迭代器 
	for(rit=s.rbegin();rit!=s.rend();rit++)
	{
		cout<<*rit<<" ";
	}
	cout<<endl;//回车换行 
	//清空集合 
	s.clear();
	//输出集合的大小，为0 
	cout<<s.size()<<endl;
	return 0;
}
运行结果：
12 8 1
0
5.元素的检索
使用find()方法对集合进行搜索,如果找到查找的键值，则返回该键值的迭代器位置 
否则，返回集合最后一个元素后面的一个位置，即end()

#include <set>
#include <iostream>
using namespace std;
int main(int argc, char* argv[])
{
	set<int> s;
	s.insert(8);
	s.insert(1);
	s.insert(12);
	s.insert(6);
	s.insert(8);
	set<int>::iterator it; //定义前向迭代器 
	//查找键值为6的元素 
	it=s.find(6);
	if(it!=s.end())//找到 
		cout<<*it<<endl;
	else//没找到 
		cout<<"not find it"<<endl;
	//查找键值为20的元素 
	it=s.find(20);
	if(it!=s.end())//找到 
		cout<<*it<<endl;
	else//没找到 
		cout<<"not find it"<<endl;
	return 0;
}
运行结果
6 
not find it 
6.自定义比较函数
使用insert()将元素插入到集合中去的时候，集合会根据设定的比较函数将该元素
放到该放的节点上去。在定义集合的时候，如果没有指定比较函数,那么采取默认的 
比较函数，即按键值由小到大的顺序插入元素

(1)如果元素不是结构体，那么，可以编写比较函数
#include <set>
#include <iostream>
using namespace std;
//自定义比较函数myComp,重载()操作符 
struct myComp
{
	bool operator()(const int &a,const int &b)
	{
		if(a!=b)
			return a>b;
		else
			return a>b;
	}
};

int main(int argc, char* argv[])
{
	//定义元素类型为int的集合对象s,当前没有任何元素 
	//采用比较函数myComp
	set<int,myComp> s;
	s.insert(8);
	s.insert(1);
	s.insert(12);
	s.insert(6);
	s.insert(8);
	set<int,myComp>::iterator it;//定义前向迭代器 
	for(it=s.begin();it!=s.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
	return 0;
}
运行结果
12 8 6 1 
(2)如果元素是结构体,那么,可以直接把比较函数写在结构体内。
#include <set>
#include <string>
#include <iostream>
using namespace std;
struct Info
{
	string name;
	float score;
	//重载运算符"<"操作符，自定义排序规则 
	bool operator < (const Info &a) const
	{
		//按sccore由大到小排列。如果要从小到大使用>即可 
		return a.score<score;
	}
};
int main(int argc, char* argv[])
{
	定义元素类型为Info结构体的集合对象s,当前没有任何元素 
	set<Info> s;
	//定义Info类型的元素 
	Info info;
	//插入3个元素 
	info.name="Jack";
	info.score=80.5;
	s.insert(info);
	info.name="Tomi";
	info.score=20.5;
	s.insert(info);
	info.name="Nacy";
	info.score=60.5;
	s.insert(info);
	set<Info>::iterator it;//定义迭代器 
	for(it=s.begin();it!=s.end();it++)
	{
		cout<<(*it).name<<" : "<<(*it).score<<endl;
	}
	return 0;
} 
运行结果：
Jack : 80.5
Nacy : 60.5
Tomi : 20.5