STL Day2

STL 是⼀个 C++ 软件库，⾥⾯包含算法（algorithms）、容 器（containers）、函数（functions）、迭代器（iterators）

一、string

1.创建string类型变量

string s(int n,char c); 创建一个string，由n个c组成，注意c是字符型要用单括号''

2.读入string

cin>>s; 读入s，遇到空格或回车停止，无论原先s是什么内容都会被新读入的数据替代 getline(cin,s); 读入s，空格也同样会读入，直到回车才会停止

3.函数

赋值运算符：= 将后面的字符串赋值给前面的字符串O(n)
比较运算符：== != < <= > >= 比较的是两个字符串的字典序大小 O(n)
连接运算符：+ += 将一个运算符加到另一个运算符后面O(n)
s[index] 返回字符串s中下标为index的字符，string中下标也是从0开始O(1)
s.substr(p,n) 返回从s的下标p开始的n个字符组成的字符串，如果n省略就取到底O(n)
s.length()返回字符串的长度O(1)
s.empty()判断s是否为空，空返回1，不空返回0，O(1)
s.erase(p0,len) 删除s中从p0开始的len个字符，如果len省略就删到底O(n)
s.erase(s.begin()+i) 删除下标为i个字符 O(n)
s1.replace(p0,len0,s2,pos,len) 删除p0开始的len0个字符，
	然后在p0处插入串s2中从pos开始的len个字符，后两个参数可以省略 O(n)
s1.find(s2,pos) 从前往后，查找成功时返回第一次出现的下标，失败返回string::npos的值 (-1) O(n*m)
s1.rfind(s2,pos) 从pos开始从后向前查找字符串s2中字符串在当前串后边第一次出现的下标 O(n*m)

insert大全
​str.insert(6,str2);  往str的第六位插入str2
str.insert(6,str3,3,4);  把str3的【3，4】擦汗如str的第六位  
str.insert(10,"that is cool",8);  在str的第十位 插入中间字符串的前八位 
str.insert(10,"to be ");   在str的第十位 插入该字符串 
str.insert(15,6,':');   在str的第15位 插入6个该字符 
it = str.insert(str.begin()+5,','); 在str的第5位 插入“，” 
str.insert (str.end(),3,'.');  在str的结束 插入3个“.” 
str.insert (it+2,str3.begin(),str3.begin()+3); 
在it（指向第五位） 后面两位的位置上，插入 （str3.begin(),str3.begin()+3） 

二、vector

1.创建

#include <bits/stdc++.h>
using namespace std;
int main()
{
    vector<int>v1;
    创建一个存int类型的动态数组，int可以改成其它类型
    vector<double>v2{1,1,2,3,5,8};
    创建一个存double类型的动态数组，长度为6，1 1 2 3 5 8分别存在v[0]~v[5]
    vector<long long>v3(20);
    创建一个存long long类型的动态数组，长度为20，v[0]~v[19]默认为0
    vector<string>v4(20,"zzuacm");
    创建一个存string类型的动态数组，长度为20，存的都是"zzuacm"
    vector<int>v5[3];
    相当于存int的二维数组，一共3行，每行的列可变
    vector<vector<int>>v5{{1,2},{1},{1,2,3}};
    存int的二维数组，行和列都可变，初始状态
    return 0;
}

vector<type>v 创建动态数组v，后面可以加{}或()进行初始化
type v[index] 获取v中第 index 个元素 O(1)
v.push_back(type item) 向v后⾯添加⼀个元素item O(1) 
v.pop_back() 删除 v 最后⼀个元素 O(1)
v.size() 获取 v 中元素个数，返回size_type类型 O(1)
v.resize(int n) 把 v 的⻓度设定为 n 个元素 O(n)
v.empty() 判断 v 是否为空，空返回1，不空返回0，O(1)
v.clear() 清空 v 中的元素 O(size)
v.insert(iterator it,type x)向迭代器it指向元素前增加一个元素x,O(n)
v.erase(iterator it) 删除向量中迭代器指向元素,O(n)
v.front()返回首元素的引用O(1)
v.back()返回尾元素的引用O(1)
v.begin()返回首迭代器，指向第一个元素O(1)
v.end()返回尾迭代器，指向向量最后一个元素的下一个位置O(1)

2.迭代器

vector<int>::iterator it=v.begin();
auto it=v.begin();
两种等价

3.插入、删除、遍历

int main()
{
    vector<int>v{0,1,2,3,4};
    v.erase(v.begin()+3);//删除v[3]，v变为{0,1,2,4}
    v.insert(v.begin()+3,666);//在v[3]前加上666，v变成{0,1,2,666,4}
    v.front()=10;//将v[0]改成10，等同于v[0]=10;
    v.back()=20;//将v[4]改成20等同于v[v.size()-1]=20;
    for(int i=0;i<v.size();i++)
        cout<<v[i]<<" ";//使用下标访问的方法遍历v
    cout<<endl;
    for(auto i=v.begin();i!=v.end();i++)
        cout<<*i<<" ";//使用迭代器，从v.begin()到v.end()-1
    cout<<endl;
    for(auto i:v)//使用C++新特性循环遍历v，如果需要改变i的值，还需要在前面加上&
        cout<<i<<" ";
    cout<<endl;
    return 0;
}

三、队列

1.queue

1）创建方法：

queue<type>q; 建立一个存放数据类型为type的队列q

2）使用方法：

q.push(item)：在 q 的最后添加⼀个type类型元素item O(1)
q.pop()：使 q 最前⾯的元素出队 O(1)
q.front()：获取 q 最前⾯的元素 O(1) 
q.size()：获取 q 中元素个数 O(1)
q.empty()：判断 q 是否为空，空返回1，不空返回0 O(1)

 2.priority_queue

1)创建方法

​priority_queue<Type, Container, Functional>
Type：数据类型
Container：存放数据的容器，默认⽤的是 vector
Functional：元素之间的⽐较⽅法，当type可以比较时后两个可以省略
//priority_queue<int,vector<int>,greater<int> >q;

2）重载

priority_queue中存的元素如果是结构体这样无法进行比较的类型，必须要重载运算符<，相当于先使得优先队列中的元素可以进行比较再建立pq，否则直接建优先队列是会报错的

#include <bits/stdc++.h>
using namespace std;
struct Node{
    int x,y;
};
bool operator<(Node a,Node b){
    return a.x<b.x;
}
int main(){
    priority_queue<Node> pq;
    pq.push({1,3});
    pq.push({3,2});
    pq.push({2,1});
    while(!pq.empty())
    {
        cout<<pq.top().x<<' '<<pq.top().y<<endl;
        pq.pop();
    }
    return 0;
}
/*3 2
  2 1
  1 3*/

//升序队列，小顶堆
priority_queue <int,vector<int>,greater<int> > q;
//降序队列，大顶堆
priority_queue <int,vector<int>,less<int> >q;

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

 

四、set

集合(set)是一种包含对象的容器，可以快速地（logn）查询元素是否在已知几集合中。 set 中所有元素是有序地，且只能出现⼀次，因为 set 中元素是有序的，所以存储的元素必须已经定义过「<」运算符（因此如果想在 set 中存放 struct 的话必须⼿动重载「<」运算符，和优先队列一样） 与set类似的还有 [multiset]元素有序可以出现多次 [unordered_set]元素无序只能出现一次 [unordered_multiset]元素无序可以出现多次

1.基础操作

建立方法：set<Type>s;
multiset<Type>s;
unorded_set<Type>s;
unorded_multiset<Type>s;
如果Type无法进行比较，还需要和优先队列一样定义<运算符
遍历方法：
for(auto i:s)cout<<i<<" ";
//和vector的类似

2.函数

使用方法：
s.insert(item)：在 s 中插⼊⼀个元素 O(logn)
s.size()：获取 s 中元素个数 O(1)
s.empty()：判断 s 是否为空 O(1)
s.clear()：清空 s O(n)
s.find(item)：在 s 中查找⼀个元素并返回其迭代器，找不到的话返回 s.end() O(logn)
s.begin()：返回 s 中最小元素的迭代器，注意set中的迭代器和vector中的迭代器不同，
    无法直接加上某个数，因此要经常用到--和++O(1)
s.end()：返回 s 中最大元素的迭代器的后一个迭代器 O(1)
s.count(item)：返回 s 中 item 的数量。在set中因为所有元素只能在 s 中出现⼀次，
    所以返回值只能是 0 或 1，在multiset中会返回存的个数 O(logn)
s.erase(position)：删除 s 中迭代器position对应位置的元素O(logn)
s.erase(item)：删除 s 中对应元素 O(logn)
s.erase(pos1, pos2)：删除 [pos1, pos2) 这个区间的位置的元素 O(logn + pos2 - pos1)
s.lower_bound(item)：返回 s 中第一个大于等于item的元素的迭代器，找不到就返回s.end() O(logn)
s.upper_bound(item)：返回 s 中第一个大于item的元素的迭代器，找不到就返回s.end() O(logn)

五、map

map 是照特定顺序存储由 key 和 value 的组合形成的元素的容器， map 中元素按照 key 进⾏排序，每个 key 都是唯⼀的，并对应着一个value，value可以重复 map的底层实现原理与set一样都是红黑树 与map类似的还有unordered_map，区别在于key不是按照顺序排序

mp.size()：获取 mp 中元素个数 O(1)
mp.empty()：判断 mp 是否为空 O(1)
mp.clear()：清空 mp O(1)
mp.begin()：返回 mp 中最小 key 的迭代器，和set一样，只可以用到--和++操作 O(1)
mp.end()：返回 mp 中最大 key 的迭代器的后一个迭代器 O(1)
mp.find(key)：在 mp 中查找⼀个 key 并返回其 iterator，找不到的话返回 s.end() O(logn)
mp.count(key)：在 mp 中查找 key 的数量，因为 map中 key 唯⼀，所以只会返回 0 或 1 O(logn)
mp.erase(key): 在 mp 中删除 key 所在的项，key和value都会被删除 O(logn)
mp.lower_bound(item)：返回 mp 中第一个key大于等于item的迭代器，找不到就返回mp.end() O(logn)
mp.upper_bound(item)：返回 mp 中第一个key大于item的迭代器，找不到就返回mp.end() O(logn)
mp[key]：返回 mp 中 key 对应的 value。如果key 不存在，则返回 value 类型的默认构造器
    （defaultconstructor）所构造的值，并该键值对插⼊到 mp 中O(logn)
mp[key] = xxx：如果 mp 中找不到对应的 key 则将键值对 (key: xxx) 插⼊到 mp 中，
    如果存在 key 则将这个 key 对应的值改变为 xxx O(logn)

六、二进制有序集(bitset)

bitset<n>b;//建立一个可以存n位二进制的有序集
bitset<n>b(unsigned long u);//坐标从后往前计数，高位在前
bitset<n>b(string s);//将由'0'和'1'组成的字符串赋值给
支持所有位操作：| |= & &= << <<= >> >>=
cout<<b;//bitset可以直接用cout输出
b[index];//可以用下标操作符来读或写某个索引位置的二进制位
//比如bitset<10>b(5);等价于bitset<10>b("1010");
//其中cout<<b输出0000001010
//for(int i=0;i<10;i++)cout<<b[i];输出0101000000

b.count();//count函数用来求bitset中1的位数
b.size();//size函数用来求bitset的大小
b.any();//any函数检查bitset中是否有１
b.none();//none函数检查bitset中是否没有１
b.all();//all函数检查bitset中是全部为１
foo.flip();//flip函数不指定参数时，将bitset每一位全部取反
foo.set();//set函数不指定参数时，将bitset的每一位全部置为１
foo.reset();//reset函数不传参数时将bitset的每一位全部置为０
string s = foo.to_string();//将bitset转换成string类型
unsigned long a = foo.to_ulong();//将bitset转换成unsigned long类型
unsigned long long b = foo.to_ullong();//将bitset转换成unsigned long long类型 

七、去重函数（unique）

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int arr[]={3,2,2,1,2},n;
    sort(arr,arr+5);//需要先排序
    n=unique(arr,arr+5)-arr;//n是去重后的元素个数
    return 0;
}

八、排序函数（sort）

#include<bits/stdc++.h>
using namespace std;
bool cmp(int a,int b){return a>b;}
int main()
{
    int arr[]={3,2,5,1,4};
    sort(arr,arr+5);
    sort(arr,arr+5,greater<int>());//倒叙写法1
    sort(arr,arr+5,cmp);//倒叙写法2
    sort(arr,arr+5,[](int a,int b){return a>b;});//倒叙写法3
    return 0;
}

九、二分函数（lower_bound/upper_bound）

lower_bound(first, last, value)
▸ first：查找起始位置（指针或 iterator）
▸ last：查找终⽌位置（指针或 iterator）
▸ value：查找的值
▸ lower_bound 查找的范围是 [first, last)，
返回的是序列中第⼀个大于等于 value 的元素的位置，时间为 O(logn)
▸ [first, last)范围内的序列必须是提前排好序的，不然会错
▸ 如果序列内所有元素都⽐ value ⼩，则返回lastupper_bound(first, last, value)
▸ upper_bound 与 lower_bound 相似，
唯⼀不同的地⽅在于upper_bound 查找的是序列中第⼀个⼤于 value 的元素

int main()
{
    int arr[]={3,2,5,1,4};
    sort(arr,arr+5);//需要先排序
    cout << *lower_bound(arr,arr+5,3);//输出数组中第一个大于等于3的值
    return 0;
}

十、next_permutation

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int a[3] = {0, 1, 2};
    do
    {
        for (int i = 0; i < 3; i++)
            cout<<a[i]<<' ';
        cout<<endl;
    }
    while (next_permutation(a, a + 3));
    return 0;
}