STL系列

STL系列（set map multiset multimap）介绍及使用

1. 关联式容器

首先介绍 **序列式容器：**如vector list deque 因为其底层为线性序列的数据结构，所以是序列式容器。

**关联式容器：**其里面存储的是<key,value>结构的键值对，效率比序列式容器高

树形结构与哈希结构

C++STL实现了两种不同结构的关联式容器：树型结构和哈希结构；

关联式容器	容器结构	底层实现
set map multiset multimap	树型结构	平衡搜索树（红黑树）
unordered_set unordered_map unordered_multiset unordered_multimap	哈希结构	哈希表

其中，树型结构容器中的元素是一个有序的序列，而哈希结构容器中的元素是一个无序的序列。

2.键值对

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

template <class T1, class T2>
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)
{}
};

3.set

---

3.1 set的介绍

了解：

1.set是按照一定次序存储元素的容器
2.在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素
不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。
3.在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。
4.set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直
接迭代。
5.set在底层是用**二叉搜索树(红黑树)**实现的。

3.2 set的定义方式

set<int> s1;

set<int> s2(s1);

string str("abcdef");
set<char> s3(str.begin(),str.end());//构造string对象某段区间的复制品

set<int,greater<int>> s4;

3.3 set的使用

set迭代器

set插入元素时会去重

注意

1. 与map/multimap不同，map/multimap中存储的是真正的键值对<key, value>，set中只放value，但 在底层实际存放的是由<value, value>构成的键值对。
2. set中插入元素时，只需要插入value即可，不需要构造键值对。
3. set中的元素不可以重复(因此可以使用set进行去重)。
4. 使用set的迭代器遍历set中的元素，可以得到有序序列
5. set中的元素默认按照小于来比较
6. set中查找某个元素，时间复杂度为：log2 n
7. set中的元素不允许修改
8. set中的底层使用二叉搜索树(红黑树)来实现

4. multiset

multiset和set的底层实现原理一样，都是平衡搜索树（红黑树）。multiset容器和set容器的唯一区别就是，multiset允许键值冗余，即multiset容器当中存储的元素是可以重复的。

成员函数find

• set对象 返回值为val的元素的迭代器
• multiset对象 返回底层搜索树中序的第一个值为val的元素的迭代器

注意

1. multiset中再底层中存储的是<value, value>的键值对
2. 与set的区别是，multiset中的元素可以重复，set是中value是唯一的
3. multiset中的元素不能修改
4. 在multiset中找某个元素，时间复杂度为O(log2 n)

5. map

5.1 map的介绍

1. map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
2. 在内部，map中的元素总是按照键值key进行比较排序的。
3. map支持下标访问符，即在[]中放入key，就可以找到与key对应的value。
4. map通常被实现为二叉搜索树(更准确的说：平衡二叉搜索树(红黑树))。

5.2 map的定义方式

map<int, double> m1; //构造一个key为int类型，value为double类型的空容器

map<int, double> m2(m1); //拷贝构造key为int类型，value为double类型的m1容器的复制品


map<int, double> m3(m2.begin(), m2.end()); //使用迭代器拷贝构造m2容器某段区间的复制品


map<int, double, greater<int>> m4; //构造一个key为int类型，value为double类型的空容器，key比较方式指定为大

5.3 map的使用

5.3.1 map的插入

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

pair<iterator,bool> insert (const value_type& val);

insert函数的返回值

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

若待插入元素的键值key在map当中不存在，则insert函数插入成功，并返回插入后元素的迭代器和true。
若待插入元素的键值key在map当中已经存在，则insert函数插入失败，并返回map当中键值为key的元素的迭代器和false。
insert函数的参数
insert函数的参数显示是value_type类型的，实际上value_type就是pair类型的别名：
typedef pair<const Key, T> value_type;

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

#include <iostream>
#include <string>
#include <map>
using namespace std;

int main()
{
	map<int, string> m;
	//方式一：调用pair的构造函数，构造一个匿名对象插入
	m.insert(pair<int, string>(2, "two"));
	m.insert(pair<int, string>(1, "one"));
	m.insert(pair<int, string>(3, "three"));
	for (auto e : m)
	{
		cout << "<" << e.first << "," << e.second << ">" << " ";
	}
	cout << endl; //<1,one> <2,two> <3,three>
	return 0;
}

但是这种方式会使得我们的代码变得很长，pair是map中的key,value键值对，需要写参数，这样很麻烦，为了方便我们一般使用make_pair。
make_pair是函数模板

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

#include <iostream>
#include <string>
#include <map>
using namespace std;

int main()
{
	//方式二：调用函数模板make_pair，构造对象插入
	map<string, string> m;

	m.insert(pair<string, string>("sort", "排序"));
	m.insert(make_pair("insert", "插入"));
	m.insert(make_pair("left", "左边"));
	m.insert(make_pair("right", "右边"));
	map<string, string>::iterator it = m.begin();
	while (it != m.end())
	{
		//cout << *it << " ";//error:*it不可能返回两个值,map是key,value键值对
		
		//法一：
		//cout << (*it).first << ":" << (*it).second << endl;//first代表key,second代表value
		
		// 法二：
		//当迭代器节点指针管理的数据是结构体的时候，可以用箭头，pair实际就算是是结构体，成员包括key,value ，即first和second
		cout << it->first << ":" << it->second << endl;

		it++;
	}
	return 0;
}

5.3.2 map的查找

map的查找函数的函数原型如下：

iterator find (const key_type& k);

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

使用范例 map统计字符串次数

void test_map()
{
    //用map统计字符串次数
	string str[] = { "sort","hello","sort","set","map","set","list" };
    map<string, int> countMap;
    
    //方法1
    for(auto& e : str)
    {
        auto ret = countMap.find(e);
        if(ret = countMap.end())
        {
            countMap.insert(make_pair(e,1));
        }
        else
        {
            ret->second++
        }
    }
}

#include<iostream>
#include<set>
#include<map>
using namespace std;
void test()
{
    set<int>s;
    s.insert(1);
	s.insert(2);
	s.insert(1);
	s.insert(4);
	s.insert(3);
	s.insert(2);
	s.insert(5);
	
	//迭代器遍历
	set<int>::iterator it = s.begin();
	

	
	/*删除*/
	//方法1：C++的auto，比较方便，本质这里应该是迭代器，因为find返回的是迭代器
	auto f = s.find(4);
	cout<<"f= "<<*f<<endl;
	if(f != s.end())
	    s.erase(f);
    
    
    while(it != s.end())
	{
	    cout<<*it<<" ";
	    it++;
	}
	cout<<endl;
}


void test_map()
{
    
    //用map统计字符串次数
	string str[] = { "sort","hello","sort","set","map","set","list" };
    map<string, int> countMap;
    map<string,int>::iterator it = countMap.begin();
    
    //方法1
    for(auto& e : str)
    {
        auto ret = countMap.find(e);
        if(ret == countMap.end())
        {
            countMap.insert(make_pair(e,1));
            cout<<it->first<<" ";
        }
        else
        {
            ret->second++;
            cout << it->first << ":" << it->second << endl;
        }
    }
    
}
int main()
{
    test_map();
    return 0;
}