SLT--set,map,multiset,multimap

目录

关联式容器

树形结构与哈希结构

键值对

set

set的介绍

set的定义方式

set的使用

multiset

map

map的介绍

map的定义方式

map的插入

map的查找

map的删除

map的[ ]运算符重载

map的迭代器遍历

map的其他成员函数

multimap

---

关联式容器

c++STL包含了序列式容器和关联式容器:

1. 序列式容器里面存储的是元素本身,其底层为线性序列的数据结构.比如:vector,list,deque,forward_list(c++11)等.
2. 关联式容器里面存储的式结构的键值对,在数据检索式序列式容器的效率更高.比如set,map,unordered_set,unordered_map等. 

注意:c++stl当中stack,queue和priority_queue属于容器适配器,他们默认使用的基础容器分别是deque,deque,和vector. 

树形结构与哈希结构

 其中树形结构容器中的元素是一个有序的序列,而哈希结构容器中的元素是一个无序的序列.

键值对

键值对是用来表示具有一一对应关系的一种结构,该结构中一般只包含两个成员变量key和val,key代表键值,val代表与key对应的信息.

比如我们若是要建立一个英汉的字典,那么该字典中的英文单词与其对应的中文含义就是一一对应的关系,即可以通过单词找到与其对应的中文含义.

在SGI-STL中关于键值对的定义如下:

template
	struct pair
	{
		typedef T1 first_type;
		typedef T2 second_type;
		T1 first;
		T2 second;
		pair()
			:first(T1())
			, second(T2())
		{

		}
		pair(const T1& a, const T2& b)
			:first(a)
			, second(b)
		{}
	};

set

set的介绍

1. set是按照一定次序存储元素的容器,使用set的迭代器遍历set中的元素,可以得到有序序列.
2. set当中存储的元素的value都是唯一的,不可以重复,因此可以使用set进行去重.
3. 与map/multimap不同,map/multimap中存储的是真正的键值对,set中只放value,但在底层实际存放的是由构成的键值对,因此在set容器中插入元素时,只需要插入value即可,不需要构造键值对.
4. set中的元素不能被修改因为set在底层是用二叉搜索树来实现的,若是对二叉搜索树当中的某个结点值进行修改,那么这颗树将不再是二叉搜索树.
5. 在内部,set中的元素总是按照其内部比较对象所指示的特定严格弱排序进行排序,当不传入内部比较对象时,set中的元素默认按照小于来比较.
6. set容器通过key访问单个元素的速度通常比unordered_set容器慢,但set容器允许根据顺序对元素进行迭代.
7. set在底层是用平衡搜索树(红黑树)实现的,所以在set当中查找某个元素的时间复杂度为logN. 

set的定义方式

方式一:构造一个某类型的空容器.

set s1;//构造一个int类型的空容器

 方式二:拷贝构造某类型set容器的复制品.

set s2(s1);

方式三:使用迭代器拷贝构造某一段内容.

string str("abcdefg");
set s3(str.begin(),str.end());

 方式四:构造一个某类型的空容器,比较方式指定为大于.

set> s4;

set的使用

set当中常使用的成员函数如下: 

 

set当中迭代相关函数如下:

 示例:

int main()
{
	set s;
	//插入元素去重
	s.insert(1);
	s.insert(4);
	s.insert(3);
	s.insert(3);
	s.insert(2);
	s.insert(2);
	s.insert(3);
	//遍历容器方式一(范围for)
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;
	//删除元素方式一
	s.erase(3);
	//删除元素的方式二
	set::iterator pos = s.find(1);
	if (pos != s.end())
	{
		s.erase(pos);
	}
	//遍历容器的方式二(正向迭代器遍历)
	set::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	cout << s.count(2) << endl;//1
	cout << s.size() << endl;//2
	s.clear();
	cout << s.empty() << endl;//1
	set temp{ 11,22,33,44 };
	s.swap(temp);
	//遍历方式三反向迭代器遍历
	set::reverse_iterator rit = s.rbegin();
	while (rit != s.rend())
	{
		cout << *rit << " ";
		rit++;
	}
	cout << endl;//44,33,22,11
	return 0;
}

multiset

multiset容器与set容器的底层实现一样,都是平衡搜索树(红黑树),其次,multiset容器和set容器所提供的成员函数的接口基本都是一致的,这里就不再举例了,multiset容器和set容器的唯一区别就是,multiset允许键值冗余,即multiset容器当中是可以存储重复的元素的.

int main()
{
	multiset ms;
	ms.insert(1);
	ms.insert(4);
	ms.insert(3);
	ms.insert(3);
	ms.insert(2);
	ms.insert(2);
	ms.insert(3);
	for (auto e : ms)
	{
		cout << e << " ";
	}
	cout << endl;//1.2.2.3.3.3.4
	return 0;
}

 由于multiset容器允许键值冗余,因此两个容器中成员函数find和count的意义也有所不同:

 

map

map的介绍

1. map是关联式容器,它按照特定的次序(按照key来比较)存储键值key和值value组成的元素,使用map的迭代器遍历map中元素,可以得到有序序列.
2. 在map中,键值key通常用于排序和唯一的标识元素,而value中存储与此键值有关的内容,键值key和value的类型可能不同,并且在map内部,key与value通过成员类型value_type绑定在一起,并取别名为pair.
3. map容器中元素的键值key不能被修改,但是元素的value可以被修改,因为map底层的二叉搜索树是根据每个元素的键值key进行构建的,而不是值value.
4. 在内部,map中的元素总是按照键值key进行比较排序的.当不传入内部比较对象时,map中元素的键值key默认按照小于来比较.
5. map容器通过键值key访问单个元素的速度通常比unordered_,map容器慢,但map容器允许根据顺序对元素进行直接迭代.
6. map容器支持下标访问符,即在[]中放入key,就可以找到相应的value.
7. map在底层是使用平衡搜索树(红黑树)实现的,所以在map当中查找元素的时间复杂度为logN. 

map的定义方式

方式一:指定key和value的类型构造一个空容器.

map m1;

 方式二:拷贝构造某同类型容器的复制品.

map(int,double> m1(m1);

方式三:使用迭代器拷贝构造某一段内容.

map m3(m2.being(),m2.end());

 方式四:指定key和value的类型构造出一个空容器,key比较方式指定为大于.

map> m4;

map的插入

map的插入函数的函数原型如下:

pair insert(const value_type& val);

 insert函数的参数:

insert函数的参数显示是value_type类型的,实际上value_type就是pair的别名:

typedef pair value_type

因此,我们要向map容器插入元素时,需要用key和value构造出一个pair对象,然后将pair对象作为参数传入insert函数.

方式一:构建匿名对象插入:

int main()
{
	map m;
	m.insert(pair(2, "tow"));
	m.insert(pair(1, "tone"));
	m.insert(pair(3, "three"));
	for (auto e : m)
	{
		cout << "<" << e.first << "," << e.second << ">" << " ";
	}
	cout << endl;
	return 0;
}

 但是这种方式会使我们的代码变得很长,尤其是没有直接展开命名空间的情况下,因此我们常用的是方式二.

方式二:调用make_pair函数模板插入.

在库中提供一下make_pair函数模板:

template
pairmake_pair(T1 x,T2 y)
{
    return (pair(x,y));
}

我们只需要先make_pair函数传入key和value,该函数模板会根据传入参数类型进行自动隐士推导,最终构造并返回一个对应的pair对象.

int main()
{
	map m;
	m.insert(make_pair(2, "tow"));
	m.insert(make_pair(1, "one"));
	m.insert(make_pair(3, "three"));
	for (auto e : m)
	{
		cout << "<" << e.first << "," << e.second << ">" << " ";
	}
	cout << endl;
	return 0;
}

 insert函数的返回值也是一个pair对象,该pair对象中第一个成员函数类型是map迭代器类型,第二个成员的类型是一个bool类型,具体含义如下:

• 若带插入元素的键值key在map当中不存在,则插入insert函数插入成功,并返回插入后元素的迭代器和true.
• 若待插入元素的键值key在map当中已经存在,则insert函数插入失败,并返回map当中键值为key的元素迭代器和false.

map的查找

map的查找函数的函数原理如下:

iterator find(const key_type& k);

 map的查找函数是根据所给key值在map当中进行查找,若是找到了返回对应元素的迭代器,若未找到,则返回容器中最后一个元素下一个位置的正向迭代器.

int main()
{
	map m;
	m.insert(make_pair(2, "tow"));
	m.insert(make_pair(1, "one"));
	m.insert(make_pair(3, "three"));
	
	map::iterator pose = m.find(2);
	if (pose != m.end())
		cout << pose->second << endl;
	return 0;
}

map的删除

map的删除函数的函数原型如下:

size_type erase(const key_type& k);
void erase(iterator position);

 也就是说,我们既可以根据key值删除指定元素,也可以根据迭代器删除指定元素,若是根据key值进行删除,则返回实际删除元素个数.

int main()
{
	map m;
	m.insert(make_pair(2, "tow"));
	m.insert(make_pair(1, "one"));
	m.insert(make_pair(3, "three"));

	m.erase(3);
	map::iterator pose = m.find(2);
	if (pose != m.end())
		m.erase(pose);
	return 0;
}

map的[ ]运算符重载

map的[]元素符重载函数的函数原型如下:

mapped_type& operator[](const key_type& k);

 []运算符重载函数的参数就是一个key值,而这个函数的返回值如下:

(*((this->insert(make_pair(k,mapped_type()))).first)).second

就这样看着不太好理解,我们整理一下,实际上[]运算符重载实现的逻辑实际上就是一下三个步骤:

1. 调用insert函数插入键值对.
2. 拿出从insert函数获取到的迭代器
3. 返回该迭代器位置元素的值, 

对应分解代码如下:

mapped_type& operator[](const key_type& k)
{
	pair ret = insert(make_pair(k, mapped_type()));
	iterator it = ret.first;
	return it->second;
}

 那么这个函数的价值体现在哪里呢?我们来看一下下面这段代码:

int main()
{
	map m;
	m.insert(make_pair(2, "tow"));
	m.insert(make_pair(1, "one"));
	m.insert(make_pair(3, "three"));

	m[2] = "dragon";
	m[6] = "six";
	for (auto e : m)
	{
		cout << "<" << e.first << "," << e.second << ">" << " ";
	}
	cout << endl;//<1,one> <2,dragon> <3,three> <6,six>
	return 0;
}

代码中的m[2]="dragon"为列说明,通过怕[]运算符重载函数的三个步骤,不管是调用insert插入也好,是容器当中本来就已经重载也好,反正无论如何map容器当中已经存在了一个key值为2的元素,而[]运算符重载函数的返回值就是这个key值为2的元素value的引用,因此我们对该函数的返回值做修改,实际上就是对键值为2的元素的value做修改.

总结一下:

1. 如果k不在map中,则先插入键值对,然后返回该键值对中v对象的引用.
2. 如果k已经存在在map中,则返回键值为k的元素对应的v对象的引用. 

map的迭代器遍历

map当中迭代器相关的函数如下:

 遍历方式一:用正向迭代器遍历.

int main()
{
	map m;
	m.insert(make_pair(2, "tow"));
	m.insert(make_pair(1, "one"));
	m.insert(make_pair(3, "three"));
	
	map::iterator it = m.begin();
	while (it != m.end())
	{
		cout << "<" << it->first << ":" << it->second << ">" << " ";
		it++;
	}
	cout << endl;//<1:one> <2:tow> <3:three>
	return 0;
}

 遍历方式二:用反向迭代器遍历.

int main()
{
	map m;
	m.insert(make_pair(2, "tow"));
	m.insert(make_pair(1, "one"));
	m.insert(make_pair(3, "three"));
	
	map::reverse_iterator rit = m.rbegin();
	while (rit != m.rend())
	{
		cout << "<" << rit->first << ":" << rit->second << ">" << " ";
		rit++;
	}
	cout << endl; //<3:three> <2:tow> <1:one>
	return 0;
}

遍历方式三:范围for遍历

int main()
{
	map m;
	m.insert(make_pair(2, "tow"));
	m.insert(make_pair(1, "one"));
	m.insert(make_pair(3, "three"));
	
	for (auto e : m)
	{
		cout << "<" << e.first << "," << e.second << ">" << " ";
	}
	cout << endl; //<1, one> <2, tow> <3, three>
	return 0;
}

map的其他成员函数

除了上述成员函数外,set当中还有如下几个常用的成员函数:

 

使用示例:

int main()
{
	map m;
	m.insert(make_pair(2, "tow"));
	m.insert(make_pair(1, "one"));
	m.insert(make_pair(3, "three"));
	cout << m.size() << endl;

	cout << m.count(2) << endl;
	m.clear();
	cout << m.empty();
	map temp;
	m.swap(temp);
	return 0;
}

multimap

multimap容器与map容器的底层实现一样,也都是平衡搜索树(红黑树),其次multimap容器和map容器通过的接口都是基本一致的,这里也就不再举例了,multimap容器和map容器的区别与ser容器的区别一样,multimap允许键值冗余,即multimap容器当中存储的元素可以是重复的.

int main()
{
	multimap m;
	m.insert(make_pair(2, "tow"));
	m.insert(make_pair(1, "one"));
	m.insert(make_pair(3, "three"));
	m.insert(make_pair(2, "double"));
	for (auto e : m)
	{
		cout << "<" << e.first << "," << e.second << ">" << " ";
	}
	cout << endl; //<1,one> <2,tow> <2,double> <3,three>
	return 0;
}

 由于multimap容器允许键值冗余,因此两个容器中成员函数find和count的意义也有不同: