STL学习

一、STL概述

1、标准模板库

1. 标准模板库（Standard Template Library, STL）就是一些常用的数据结构（eg.链表、数组、二叉树）和算法（eg.排序、查找）的模板的集合。
2. STL基本概念
   （1）容器：可容纳各种数据类型的通用数据结构，即== 类模板==。
   （2）迭代器：依次存取容器中的元素，即== 指针==。
   （3）算法：操作容器中的元素的函数模板。eg.sort()、find()。算法与操作的数据结构类型无关，可使用在任何数据结构上。
   如：int array[100];——容器 int*——迭代器 sort——算法
   

2、容器概述

1. 用于存放各种类型的数据的数据结构，=类模板。
2. 三类容器
   （1）顺序容器：vector（动态数组）、deque（双向队列）、list（双向链表）。
   （2）关联容器（排序用）：set、mutiset、map、multimap。
   （3）容器适配器：stack（栈）、queue、priority_queue（优先级队列）。

3、顺序容器

1. vector：动态数组。元素在内存中连续存放。存取任何元素在常数时间完成。尾端增删元素快。（类似顺序表）

#include <vector> //头文件

2. deque：双向队列。元素在内存中连续存放。存取任何元素在常数时间完成（比vector慢一点）。首尾端增删元素快。（类似顺序表）

#include <deque> //头文件

3. list：双向链表。元素在内存中不连续存放。增删任何元素在常数时间完成。不支持随机存取。
   

#include <list> //头文件

4、关联容器

• 元素是排序的。查找性能好。
• 插入任何元素，按相应顺序规则确定其位置。
• 一般用平衡二叉树实现，插入、检索时间都是O(log(n))。

1. set/multiset：集合。set不允许有相同元素，multiset允许。

#include <set> //头文件

2. map/multimap：元素有且仅有两个成员变量，一个为first，一个为second，map根据first值对元素从小到大排序，根据first检索元素。map与multimap不同在于是否允许有相同first值元素。

#
include <map> //头文件

5、容器适配器

1. stack：栈。是项的有限序列。后进先出。

#include <stack> //头文件

2. queue：队列。先进先出。

#include <queue> //头文件

3. priority_queue：优先级队列，最高优先级元素第一个出列。

#include <queue> //头文件

二、vector

概念：vector相当于数组，模板类型相当于存放的内容。

1. 构造

#include<vector>
int main()
{

	vector<int> v;//定义一个空vector
	vector<int> v2(4);//定义一个大小为4的vector，初始为0，即[0,0,0,0]
	vector<int> v3(4,6);//[6,6,6,6]
	vector<int> v4{1,2,3,4,5};
	for(auto x:v)//相当于for(int::iterator x=v.begin();x!=v.end();x++)
	{
		cout<<x;
	}
}

2. 获取元素
   用at或[]

vector<int> v{1,2,3,4,5};
cout<<v[1];//打印2
cout<<v.at(2);//打印3

3. 方法

vector<int> v{1,2,3,4,5};
v.push_back(6);//在后面追加内容
v.resize(10);//设置v大小为10，不够的用0占位
v.erase(v.begin());//删除第一个元素
v.erase(--v.end());//删除最后一个元素
cout<<v.front();//第一个元素，即v[0]
cout<<v.back();//最后一个元素，即v[v.size()-1]或*--v.end()
sort(v.begin(),v.end());//从小到大排序，默认less<int>()
sort(v.begin(),v.end(),greater<int>());//从大到小排序

三、stack

概念：栈

#include<stack>
int main()
{
	stack<int> s;
	stack<int> s1{1,2,3};
	s1.push(4);
	cout<<s.top();//取栈头元素
	s.pop();//无返回值，弹出一个元素
	cout<<s.size();
}

四、queue

概念：队列

#include<stack>
int main()
{
	queue<int> q;
	q.push(4);
	cout<<s.front();//取队头元素
	q.pop();//无返回值，弹出一个元素
	cout<<q.size();
}

五、map(unordered_map)

概念：映射

1. map

#include<map>//底层树状结构，有序
int main()
{
	map<int,int> m;
	m[2]=5;
	m[4]=6;
	m[3]=9;
	for(auto i:m)
		cout<<i.first<<" "<<i.second<<endl;//打印2 5
		//3 9
		//4 6
}

2. unordered_map

#include<unordered_map>//底层哈希结构,无序
bool cmp(pair<int,int> a,pair<int,int> b)
{
	return a.first>b.first;
}
int main()
{
	unordered_map<int,int> m;
	m[2]=5;
	m[4]=6;
	m[3]=9;
	vector<pair<int,int>> 		 
	v(m.begin(),m.end());
	sort(m.begin(),m.end(),cmp);
	for(auto i:m)
		cout<<i.first<<" "<<i.second<<endl;//打印2 5
		//3 9
		//4 6
		
}

六、set(unordered_set)

概念：没有重复元素的集合。用于计数、去重。
1.

set<int> s;//树状结构，有序
unordered_set<int> s2;//哈希结构，无序，快
s.insert(3);
s.insert(4);
cout<<s.size()<<endl;
for(auto i:s)
	cout<<i<<" ";
cout<<endl;
for(auto it=s.begin();it!=s.end();it++)
	cout<<*it<<" ";
cout<<endl;

2. unordered_set和vector的相互转换

//vector->unordered_set
vector<int> num1;
unordered_set<int> num2(num1.begin(),num1.end());

//unordered_set->vector
return vector<int> (num2.begin(),num2.end());

3. unordered_set的方法

• nums.count(i)：返回nums中i元素的个数，答案只有0和1。
• nums.erase(i)：查找并删除元素i，返回删除的i的个数，答案只有0和1。
• 4. set_intersection（取集合交集）、set_union（取集合并集）、set_difference（取集合差集）、set_symmetric_difference（取集合对称差集）等函数。

七、deque

概念：双端队列

deque<int> d;
d.push_back(1);
d.push_front(4);
d.pop_back();
d.pop_front();
for(auto i:d) cout<<i;
for(auto i=d.begin();i!=d.end();i++) cout<<*i;

八、list

概念：双向链表

list<int> l;
l.push_back(6);//在结尾添加元素
l.pop_back();//删除结尾元素
l.push_front(9);//在开头添加元素
l.pop_front();//删除开头元素

list其他函数

九、算法题应用

## 1、算两个数组的交集

思路1：定义两个unordered_set，一个存储vector，一个存储用count()遍历后找到的相同元素。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> num1(nums1.begin(),nums1.end());
        unordered_set<int> num2;
        for(auto i:nums2)
        {
            if(num1.count(i)==1)
            {
                num2.insert(i);
            }
        }
        return vector<int>(num2.begin(),num2.end());
    }
};

思路2：定义一个unordered_set，放第一个vector；一个vector放用erase()遍历得到的相同的元素。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> num1(nums1.begin(),nums1.end());
        vector<int> num2;
        for(auto i:nums2)
        {
            if(num1.erase(i)==1)
            {
                num2.push_back(i);
            }
        }
        return num2;
    }
};

思路3：两个set，一个vector。使用set的set_intersection（取集合交集）函数和insert_iterator<vector函数把结果插入vector中。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        set<int> num1(nums1.begin(),nums1.end());
        set<int> num2(nums2.begin(),nums2.end());
        vector<int> ans;
        set_intersection(num1.begin(),num1.end(),num2.begin(),num2.end(),insert_iterator<vector<int>> (ans, ans.begin()));
        return ans;
    }
};

思路4：一个unordered_map，一个vector。