STL笔记

写在前面

这是考csp时做的笔记，希望没有错~~

基础信息

概念

STL，英文全称standard template library，中文可译为标准模板库或者泛型库，其包含有大量的模板类和模板函数，是C++提供的一个基础模板的集合，用于完成诸如输入/输出、数学计算等功能。

组成

容器、算法、迭代器、函数对象、适配器、内存分配器

容器

容器：就是一些模板类的集合，封装的是住址数据的方法，即数据结构

分类如下

1. 序列容器：元素在容器中的位置与元素的值无关，容器时不排序的，将元素装入容器时，指定在什么位置就会位于什么位置。包括vector、list、deque、array、forward_list
2. 排序容器：排序容器中的元素默认是由小到大的，插入元素的时候元素会插入到适当位置。包括set、multiset、map、multimap
3. 哈希容器：元素未排序，元素位置由哈希函数确定。包括unordered_set、unordered_multset、unordered_map、unordered_multmap

array<T,N>：数组容器，包含N个T类型的元素，长度固定不变，不能增删元素。类似数组
vector：向量容器，存放T类型的元素，长度可变。类似顺序表。
deque：双端队列容器。类似带头指针和尾指针的单链表。
list：链表容器。类似带头指针和尾指针的双链表。
forward_list：正向链表容器。类似只带头指针的单链表。
stack和queue本质也属于序列容器，但一般被称为容器适配器》

容器常用函数

begin()：第一个元素
end()：最后一个元素的后一个位置
rbegin()：最后一个元素
rend()：第一个元素的前一个位置
size()：返回实际元素个数
capacity()：返回当前容量
front()：返回一个元素的引用
back()：返回最后一个元素的引用
push_back()：序列尾部添加元素
pop_back()：移出序列尾部的元素
insert()：指定位置插入>=1个元素
at()：经过边界检查的索引访问元素

迭代器

简单说，就是类似C++中的指针

一些操作~

前向：支持++p、p++、*p、==、！=
双向：–p、p–
随机：p+=i:使得p往后移动i个元素
p-=i:使得p往前移动i个元素
p+i:返回p后面第i个元素的迭代器
p-i:返回p前面第i个元素的迭代器
p[i]:返回p后面第i个元素的引用。

此外，两个随机访问迭代器p1、p2还可以用<、>、<=、>=运算符进行比较。表达式 p2-p1也是有定义的，其返回值表示p2所指向元素和p1所指向元素的序号之差（也可以说是p2和p1之间的元素个数减1)。

容器与迭代器关系

array、vector、deque–>随机访问迭代器
list、set/multset、map/multmap–>双向迭代器
forward_list、unordered_map/unordered_multmap、unordered_set/unordered_multset–>双向迭代器
stack、queue–>不支持迭代器

4种定义方法：

ps:array、vector、deque都可以用

正向迭代器：容器名::iterator 迭代器名
反向迭代器：容器名::trverse_iterator 迭代器名
常量正向迭代器：容器名::const_iterator 迭代器名
常量反向迭代器：容器名::const_inverse_iterator 迭代器名

序列式容器

序列式容器不会对存储的元素的进行排序，元素排序的顺序取决于存储的顺序。这种类型便于实现存储大量数据，进行对数据的排序、查找、求和等

vector

初始化操作

这里面的常量都可以用已经声明过的变量表示

其中v是指容器名

创建空容器：vector v
创建有N大小的空容器：vector v(N)
创建并初始化容器：vector v{1,2,3,4}
创建有N大小且初始值都是1的容器：vector v(N,1)

示例

//vector-iterator-定义输入输出（注意：此处使用的是随机访问迭代器，所以有多种遍历方式）
#include<iostream>
#include<vector>
using namespace std;
int main()
{
  vector<int> v;//定义容器 
  vector<int>::iterator it;//定义迭代器
  for(int i=0;i<10;i++) v.push_back(i); //装入元素
  
  /*第一种遍历迭代方法：像普通数组一样使用即可，注意此处用的是容器名*/ 
  for(int i=0;i<v.size();i++) cout<<v[i]<<" ";
  
  /*第二种遍历方法：用！=*/
  for(it=v.begin();it!=v.end();it++) cout<<*it<<" "; 
  
  /*第三种遍历方法：用<*/
  for(it=v.begin();it<v.end();it++) cout<<*it<<" "; 
  
  /*第间隔输出：*/
  for(it=v.begin();it!=v.end();it+=2) cout<<*it<<" "; 
  return 0; 
}  

list

初始化定义

这里面的常量都可以用已经声明过的变量表示

创建空容器：list l
创建有N大小的空容器：list l(N)
创建并初始化容器：list l{1,2,3,4}
创建有N大小且初始值都是1的容器：list l(N,1)

示例

#include<iostream>
#include<list>
using namespace std;
int main()
{
  list<int> v;
  list<int>::iterator it;//定义迭代器
  for(int i=0;i<10;i++) v.push_back(i); //装入元素
  
  /*在容器第0位后插入元素*/
  v.insert(v.begin(),0); 
    
  /*删除1*/
  v.remove(1);
  
  /*第二种遍历方法：用！=*/
  for(it=v.begin();it!=v.end();++it) cout<<*it<<" ";
  cout<<endl; 
  return 0;
}

关联式容器

key-value键值对式：键值对可以通过键迅速找到值，从而避免了遍历，极大的提高了增删查改的效率，且默认会根据各元素的大小做升序排序

map

定义

map<int,int,std::greater > m;//构建升序容器
map<int,int,std::less > m;//构建降序容器
map<int,int> m;//构建默认降序容器
map<int,int> m{{key1,value1},{key2,value2}};//构建并初始化容器

示例

#include<iostream>
#include<map>
using namespace std;
int main()
{
  map<int,int,std::greater<int> > m;//构建升序容器 
  //map<int,int,std::less<int> > m;//构建降序容器 
  //map<int,int> m;//构建默认降序容器 
  map<int,int>::iterator it;//定义迭代器 
  
  for(int i=0;i<10;i++) m[i]=i*10;//m[i]里的i是key,=后面赋值的内容是value
  
  m.insert(m.begin(),{10,100});//插入  有点小错误 
  
  for(it=m.begin();it!=m.end();++it)
      cout<<it->first<<":"<<it->second<<" ";//it->first、it->second分别代表key、value 
  cout<<endl;
  
  for(map<int,int>::iterator it=m.find(5);it!=m.end();++it)//从key=5的地方开始遍历 
      cout<<it->first<<":"<<it->second<<" ";
  cout<<endl;
    
  return 0;
 } 

set

set的键值对必须一致

定义

set s;//构建容器(升降序同map)
set s{1,2,3};//构建并初始化容器（无需键值对模式）

示例

#include<iostream>
#include<set>
using namespace std;
int main()
{
  set<int> s;//定义 
  for(int i=0;i<10;i++) s.insert(i);//set的键值对必须一致 
  for(set<int,int>::iterator it=s.begin();it!=s.end();++it) cout<<*it;//输出 
  cout<<endl;
  for(set<int,int>::iterator it=s.find(3);it!=s.end();++it) cout<<*it;//输出3(包括)以后的 
  return 0; 
}

无序关联式容器

这个我没看，就没笔记啦~~~

STL容器适配器

将不适配的序列式容器（vector、deque、list）变得适用

分类

stack：后入先出
queue：先入先出
priority_queue：保证最大元素再队列前端，封装了vector容器的适配器模板

stack

定义

stack s;//创建空容器
stack<int,list > s;//使用list容器作为基础容器的空stack容器适配器

示例

#include<iostream>
#include<stack>
using namespace std;
int main()
{
  stack<int> s;//定义 
  for(int i=0;i<10;i++) s.push(i);//输入 
  while(!s.empty())
  {
    cout<<s.top()<<" ";//输出 
    s.pop();//弹出 
  }
  return 0;
 } 

queue

queue q;//定义空容器
queue<int，list > q//使用list容器作为基础容器的空queue容器适配器

示例

#include<iostream>
#include<queue>
using namespace std;
int main()
{
  queue<int> q;//定义 
  for(int i=0;i<10;i++) q.push(i);//输入 
  while(!q.empty())
  {
    cout<<q.front()<<" ";//输出 
    q.pop();//弹出 
  }
  return 0;
 } 

sort

sort() 只对 array、vector、deque 有用