STL学习笔记

1 STL基础

STL(standard template library) ，中文可译为标准模板库或者泛型库，其包含有大量的模板类和模板函数，是 C++ 提供的一个基础模板的集合，用于完成诸如输入/输出、数学计算等功能。如今 STL 已完全被内置到支持 C++ 的编译器中，无需额外安装，STL 就位于各个 C++ 的头文件中，即它并非以二进制代码的形式提供，而是以源代码的形式提供。

C++ 标准模板库的核心包括以下三个组件：

组件	描述
容器（Containers）	容器是用来管理某一类对象的集合。C++ 提供了各种不同类型的容器，比如 deque、list、vector、map 等。
算法（Algorithms）	算法作用于容器。它们提供了执行各种操作的方式，包括对容器内容执行初始化、排序、搜索和转换等操作。
迭代器（iterators）	迭代器用于遍历对象集合的元素。这些集合可能是容器，也可能是容器的子集。
其他部分：
组件	描述
–	–
函数对象	如果一个类将 () 运算符重载为成员函数，这个类就称为函数对象类，这个类的对象就是函数对象（又称仿函数）。
适配器	可以使一个类的接口（模板的参数）适配成用户指定的形式，从而让原本不能在一起工作的两个类工作在一起。值得一提的是，容器、迭代器和函数都有适配器。
内存分配器	为容器类模板提供自定义的内存申请和释放功能，由于往往只有高级用户才有改变内存分配策略的需求，因此内存分配器对于一般用户来说，并不常用。

2 容器
概念：容器是储存其他对象的对象。被储存的对象必须是同一类型。
目前，STL 中已经提供的容器主要如下：

容器	解释
vector	一种向量。
list	一个双向链表容器，完成了标准 C++ 数据结构中链表的所有功能。
queue	一种队列容器，完成了标准 C++ 数据结构中队列的所有功能。
stack	一种栈容器，完成了标准 C++ 数据结构中栈的所有功能。
deque	双端队列容器，完成了标准 C++ 数据结构中队列的所有功能。
priority_queue	一种按值排序的队列容器。
set	一种集合容器。
multiset	一种允许出现重复元素的集合容器。
map <key, val>	一种关联数组容器。
multimap <key, val>	一种允许出现重复 key 值的关联数组容器。

2.1 序列容器

常用容器： vector、deque、list、queue、stack

概念： 序列是对基本容器的一种改进，在保持其基础功能上增加一些我们需要的更为方便的功能。

要求： 序列的元素必须是严格的线性顺序排序。因此序列中的元素具有确定的顺序，可以执行将值插入到特定位置、删除特定区间等操作。

序列容器基本特征： 以下用 t 表示类型为T（储存在容器中的值的类型）的值，n表示整数，p、q、i 和 j 表示迭代器。

不同容器特有的特征：

【queue】队列
头文件queue，queue不允许随机访问队列元素，不允许遍历队列，可以进行队列基本操作；可以将元素添加到队尾，从队首删除元素，查看队尾和队首的值，检查元素数目和测试队列是否为空。

基本操作
queue<int> a;    //声明一个空队列

a.empty()        //判断队列是否为空，如果为空则返回 1，不为空则返回 0 
a.size()         //返回队列元素个数
a.front()        //返回指向队首元素的引用
a.back()         //返回指向队尾元素的引用
a.push(t)        //队尾插入元素
a.pop()          //删除队首元素

注：
pop() 是一个删除数据的方法，不是检索数据的方法！！！
如果要使用队列中的值，首先要使用 front() 来检索这个值，然后用 pop() 将他从队列中删除。

【deque】双端队列（double ended queue）
C++中deque是stack和queue默认的底层实现容器，deque是可以两边扩展的，而且deque里元素并不是严格的连续分布的。

头文件deque，在STL中deque类似vector，并且支持随机访问；区别在于：

• 从deque起始位置插入删除元素时间是固定的；
• 为了实现在deque俩段执行插入和删除操作的时间为固定这一目的，deque对象设计比vector设计更为复杂一些。因此，在序列中部执行插入删除操作时，vector更快一些；

基本操作
deque<int> a;           //声明一个空队列

a.empty()               //判断队列是否为空，如果为空则返回 1，不为空则返回 0 
a.size()                //返回队列元素个数
a.front()               //返回指向队首元素的引用
a.back()                //返回指向队尾元素的引用
a.push_front()          //从队首插入
a.push_back()           //从队尾插入
a.push(t)               //队尾插入元素
a.pop_front()                 //删除队首元素   （出口）
a.pop_back()                 //删除队尾元素   （入口）
a[n]
a.at(t)

【vector】数组
这个是用的最多的，基本就拿来当数组来用，vector是最简单也是最重要的一个容器。其头文件为vector
vector是数组的一种类表示，它有以下优点 ：

• 自动管理内存、动态改变长度并随着元素的增减而增大或缩小。
• 在尾部添加元素是固定时间，在头部或中间添加或删除元素是线性时间。
• vector是可反转容器。

基本操作
vector<int> a;         //声明

a.front();
a.back();
a.push_back();
a.pop_back();
a[n]
a.at(t)

注：
*a[n]和a.at(n)都返回一个指向容器中第n个元素的引用。
区别在于：如果n落在容器有效区间之外，a.at(n)将执行边界检查，并引发out_of_range异常。
*之所以vector没有push_front()，是因为vector执行此表达式复杂度为线性时间，而deque为固定时间。
    

构造函数：
vector（）：创建一个空的vector。
vector（itn nSize）：创建一个vector，元素个数为nSize。
vector（int nSize， const T& t）：创建一个vector，元素个数为nSize，且值均为t。
vector（const vector&）：拷贝构造函数。
vector<int>a,b(n,0)的意思就是 创建了一个 int 类型的空的vector容器a，和一个 int 类型n个元素，且值均为0的vecotr容器b。

基本操作

 //声明
整数型：    vector<int>a;
字符型：    vector<char>a;
字符串型：  vector<string>a; (注意字符串型输入输出用cin和cout)
 
固定vector的大小：
           vector<int>a(105);

a.front();
a.back();
a.push_back();
a.pop_back();
a[n]
a.at(t)

注：
*a[n]和a.at(n)都返回一个指向容器中第n个元素的引用。
区别在于：如果n落在容器有效区间之外，a.at(n)将执行边界检查，并引发out_of_range异常。
*之所以vector没有push_front()，是因为vector执行此表达式复杂度为线性时间，而deque为固定时间。

大小和容量

方法	效果
size()	返回容器的大小
empty()	判断容器是否为空
max_size()	返回容器最大的可以存储的元素
capacity()	返回容器当前能够容纳的元素数量

//回容器的最大可以存储的元素个数，这是个极限，当容器扩展到这个最大值时就不能再自动增大  
a.max_size() 
// return length of sequence  
a.size() 
// return current length of allocated storage 
a.capacity() 
    
a.resize()，设置大小（size），默认为0
    vv.resize(int n,element)表示调整容器vv的大小为n，扩容后的每个元素的值为element，默认为0
resize()会改变容器的容量和当前元素个数
    
a.reserve()，设置容量（capacity）;

排序、翻转、删除、查找

//将元素从小到大的顺序排列（默认）：
sort(c.begin(),c.end());
sort(c.begin(),c.end(),cmp):
//注意：cmp在编写自定义比较的时候，相等情况应当返回false，不然会出bug。


//翻转
reverse(d.begin(),d.end());   

//删除
a.erase(vc.begin(),vc.end()); ///a.erase()可以删除一个或多个元素
说明：
a.erase()函数中添加的地址范围是  左闭右开区间,删除内容后，如果后面还有元素，会自动补全空位。
注意：
vc.erase()函数中不是直接加要删除的内容，下面例子是错误的。
vc.erase('a');

不同于map（map有find方法），vector本身是没有find这一方法，其find是依靠algorithm来实现的。 需要添加 #include < algorithm >

#include <iostream>
#include <algorithm>
#include <vector>
 
int main()
{
    using namespace std;
 
    vector<int> vec;
 
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(3);
    vec.push_back(4);
    vec.push_back(5);
    vec.push_back(6);
 
    vector<int>::iterator it = find(vec.begin(), vec.end(), 6);
 
    if (it != vec.end())
    {
        cout<<*it<<endl;
         //返回 索引
   		 int nPosition = distance(vec.begin(),it);
   		 cout <<"  find in the vector at position: " <<nPosition<<endl;
    }
    else
        cout<<"can not find"<<endl;
    
   
 
    return 0;
}

二维数组
二维数组的提前申请空间：

int main()
{
    //初始化1
    vector<vector<int>> matrix;        //假设这是一个4*3的矩阵
    int row=4,col=3;
    
    matrix.resize(row);               //设置大小（size），默认为0          
    for(int i=0;i<matrix.size();i++)
        matrix[i].resize(col);
    
    // 初始化2
    vector<vector<int> > ans(n);
        for(int i = 0 ; i < n ; i++)
        {
            ans[i].resize(n);
        }
    
 
    //接下来就可以用下标运算访问了
    matrix[1][2]=233;
    matrix[0][0]=422;
    for(int i=0;i<matrix.size();i++){
        for(int j=0;j<matrix[i].size();j++){
            printf("%d ",matrix[i][j]);
        }
        printf("\n");
    }
    return 0;
}

【stack】堆栈
头文件stack
stack是一个适配器，它给底层类（默认vector）提供典型栈接口；
stack不允许随机访问栈元素，不允许遍历栈，把使用限制在定义栈的基本操作上；
可以将值压入栈顶，从栈顶弹出元素，查看栈顶的值，检查元素数目，测试栈是否为空；

基本操作
stack<int> a;        //声明

a.empty()	         //如果栈为空，返回true，否则返回false
a.size()	         //返回栈中元素数目
a.top()	             //返回指向栈顶元素的引用
a.push(t)	         //在栈顶插入x
a.pop()	             // 删除栈顶元素

注：
pop() 是一个删除数据的方法，不是检索数据的方法！！！
如果要使用栈顶的值，首先要使用 top() 来检索这个值，然后用 pop() 将他从栈顶删除。

【list】链表

链表的基本操作：

list<int> numbers;                //链表初始化
for(int i=0; i<n; i++ )
    numbers.push_back(i);         //链表的建立

numbers.begin();                  //链表头元素
numbers.end();                    //链表尾元素
numbers.erase(current);           //删除链表元素
numbers.size();                   //链表尺寸

2.2 关联容器

关联容器与序列容器有着根本性的不同，序列容器的元素是按照在容器中的位置来顺序保存和访问的，而关联容器的元素是按关键元素来保存和访问的。关联容器支持高效的关键字查找与访问。两个主要的关联容器类型是map与set。
【set】集合
set里面每个元素只存有一个key，它支持高效的关键字查询操作。set对应数学中的“集合”。

特点：

储存同一类型的数据元素（这点和vector、queue等其他容器相同）；

• 每个元素的值都唯一（没有重复的元素）；
• 根据元素的值自动排列大小（有序性）；
• 无法直接修改元素；
• 高效的插入删除操作；

基本操作
set<int> a;            //声明

a.begin();            //返回指向第一个元素的迭代器
a.end();              //返回指向超尾的迭代器
a.clear();            //清空容器a
a.empty();            //判断容器是否为空
a.size();             //返回当前容器元素个数
a.count(x);           //返回容器a中元素x的个数
a.insert(x);          //插入元素，其中a为set<T>型容器，x为T型变量

了解
a.insert(first,second);       //其中first为指向区间左侧的迭代器，second为指向右侧的迭代器。作用是将first到second区间内元素插入到a（左闭右开）。
a.erase(x)：删除建值为x的元素
a.erase(first,second)：删除first到second区间内的元素（左闭右开）
a.erase(iterator):删除迭代器指向的元素
注：set中的删除操作是不进行任何的错误检查的，比如定位器的是否合法等等，所以用的时候自己一定要注意。
lower_bound（x1）:返回第一个不小于键参数x1的元素的迭代器
upper_bound（x2）:返回最后一个大于键参数x2的元素的迭代器
由以上俩个函数，可以得到一个目标区间，即包含集合中从'x1'到'x2'的所有元素
set_union():对集合取并集
set_intersection():对集合取交集，它的接口与set_union()相同。
    
    

【map && unordered_map】映射
分别在头文件和<unordered_map>中，别混了。
这两个刷题时用的也非常多，其中map的底层实现是RB-Tree（红黑树），因此会根据键值自动进行排序，默认是字典序。而unordered_map的底层实现是哈希。

因此，如果只是单纯的用来创建某种映射关系的话，推荐unordered_map，效率会高一些。

map是一种key-value型容器，其中key是关键字，起到索引作用，而value就是其对应的值。与set不同的是它支持下标访问。头文件是map

特点：

• 增加和删除节点对迭代器的影响很小(高效的插入与删除)；
• 快速的查找（同set）；
• 自动建立key-value的对应，key和value可以是任何你需要的类型；
• 可以根据key修改value的记录；
• 支持下标[]操作

map<string,int> m;         //声明一个key为string，value为int的map型容器

//插入，必须以pair形式插入
map.insert(pair<int, int>(nums[i], i));

2.3 其他

【priority_queue】优先队列

和队列基本操作相同:
top 访问队头元素
empty 队列是否为空
size 返回队列内元素个数
push 插入元素到队尾 (并排序)
emplace 原地构造一个元素并插入队列
pop 弹出队头元素
swap 交换内容

//升序队列
priority_queue <int,vector<int>,greater<int> > q;
//降序队列
priority_queue <int,vector<int>,less<int> >q;

//greater和less是std实现的两个仿函数（就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了）

【heap】最大堆和最小堆
头文件是algorithm

一般用到这四个：make_heap()、pop_heap()、push_heap()、sort_heap()；

（1）make_heap()        //构造堆 
void make_heap(first_pointer,end_pointer,compare_function); 
默认比较函数是(<)，即最大堆。 
函数的作用是将[begin,end)内的元素处理成堆的结构

（2）push_heap()        //添加元素到堆 
void push_heap(first_pointer,end_pointer,compare_function); 
新添加一个元素在末尾，然后重新调整堆序。该算法必须是在一个已经满足堆序的条件下。 
先在vector的末尾添加元素，再调用push_heap

（3）pop_heap()         //从堆中移出元素 
void pop_heap(first_pointer,end_pointer,compare_function); 
把堆顶元素取出来，放到了数组或者是vector的末尾。 
要取走，则可以使用底部容器（vector）提供的pop_back()函数。 
先调用pop_heap再从vector中pop_back元素

（4）sort_heap()        //对整个堆排序 
排序之后的元素就不再是一个合法的堆了。

void testHeap() 
{
    vector<int> data{ 3,1,2,7,5 };
    //构造堆，最大堆
    make_heap(data.begin(), data.end(), less<int>());
    //pop堆顶元素，最大的元素
    pop_heap(data.begin(), data.end(), less<int>());
    cout << data.back() << endl;//输出7
    data.pop_back();
    //往堆中添加元素
    data.push_back(4);
    push_heap(data.begin(), data.end(), less<int>());//调整堆
    //排序
    sort_heap(data.begin(), data.end(), less<int>());
    for (int x : data)
        cout << x << " ";
    cout << endl;//输出 1，2，3，4，5
}

【list】链表

链表的基本操作：

list<int> numbers;                //链表初始化
for(int i=0; i<n; i++ )
    numbers.push_back(i);         //链表的建立

numbers.begin();                  //链表头元素
numbers.end();                    //链表尾元素
numbers.erase(current);           //删除链表元素
numbers.size();                   //链表尺寸