C++ STL

阿斯卡码

已于 2024-08-02 21:56:26 修改

阅读量191

点赞数

分类专栏： ACM Acwing基础课文章标签： c++ java 开发语言

于 2021-04-16 18:45:31 首次发布

本文链接：https://blog.csdn.net/qq_52384627/article/details/115769227

版权

Acwing基础课同时被 2 个专栏收录

53 篇文章 0 订阅

订阅专栏

ACM

11 篇文章 1 订阅

订阅专栏

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

一.string
注意：
string a;
printf("%s",a.c_str());

A.创建string类型变量
1.string s; 直接创建一个空的（大小为0）的string类型变量s
2.string s=""; 创建string时直接用字符串内容对其赋值，注意字符串要用双引号""
3.string s(int n,char c); 创建一个string，由n个c组成，注意c是字符型要用单括号''

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

C.输出string
1.cout<<s; 将s全部输出到一行（不带回车）

D.string中的函数
1.赋值运算符：= 将后面的字符串赋值给前面的字符串O(n)
2.比较运算符：== != < <= > >= 比较的是两个字符串的字典序大小 O(n)
3.连接运算符：+ += 将一个运算符加到另一个运算符后面O(n)
4.s[index] 返回字符串s中下标为index的字符，string中下标也是从0开始O(1)
@5.s.substr(p,n) 返回从s的下标p开始的n个字符组成的字符串，如果n省略就取到底O(n)
6.s.length()返回字符串的长度O(1)
7.s.empty()判断s是否为空，空返回1，不空返回0，O(1)
@8.s.erase(p0,len) 删除s中从p0开始的len个字符，如果len省略就删到底O(n)
@9.s.erase(s.begin()+i) 删除下标为i个字符 O(n)
@10.s1.insert(p0,s2,pos,len) 后两个参数截取s2，可以省略 O(n)
@11.s.insert(p0,n,c) 在p0处插入n个字符c O(n)
@12.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)

二.vector

A.简介
vector 容器是 STL 中最常用的容器之一，它和 array 容器非常类似，都可以看做是对 C++ 普通数组的“升级版”。不同之处在于，array 实现的是静态数组（容量固定的数组），而 vector 实现的是一个动态数组，即可以进行元素的插入和删除，在此过程中，vector 会动态调整所占用的内存空间，整个过程无需人工干预。

B.创建vector类型
vector<type>v 创建动态数组v，后面可以加{}或()进行初始化
vector<int> a(4,3),b(3,4);
3 3 3 3 <4 4 4 =========即a(4,3)<b(3,4)


C.vector中的函数
1.type v[index] 获取v中第 index 个元素 O(1)
2.v.push_back(type item) 向v后⾯添加⼀个元素item O(1) 
3.v.pop_back() 删除 v 最后⼀个元素 O(1)
4.v.size() 获取 v 中元素个数，返回size_type类型 O(1)
5.@v.resize(int n) 把 v 的⻓度设定为 n 个元素 O(n)
6.v.empty() 判断 v 是否为空，空返回1，不空返回0，O(1)
7.v.clear() 清空 v 中的元素 O(size)
8.@v.insert(iterator it,type x)向迭代器it指向元素前增加一个元素x,O(n)
9.@v.erase(iterator it) 删除向量中迭代器指向元素,O(n)
10.v.front()返回首元素的引用O(1)//v.front()=10,将v[0]改成10，等同于v[0]=10;也可以返回v[0]的数值
11.v.back()返回尾元素的引用O(1)//v.back()=20,将v[最后元素的下标]改成20，等同于v[最后元素的下标]=20;也可以返回v[最后元素的下标]的数值
12.v.begin()返回首迭代器，指向第一个元素，类似指针O(1)
13.v.end()返回尾迭代器，指向向量最后一个元素的下一个位置，类似指针O(1)

D.遍历vector的三种方法
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;
}

E.关于迭代器
vector<int>::iterator it=v.begin();
auto it=v.begin();两者等价
在这⾥ it 类似于⼀个指针，指向 v 的第⼀个元素
it 等价于 &v[0]
*it 等价于 v[0]
it 也可以进⾏加减操作，例如 it + 3 指向第四个元素
it++ 后it指向的就是v的第二个元素(v[1])了

三.queue

普通队列：

A.简介
queue只能在容器的末尾添加新元素，只能从头部移除元素。

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

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

D.队列清空操作
q=queue<int> ();


优先队列：

A.简介
priority_queue中出队顺序与插⼊顺序⽆关，与数据优先级有关，本质是一个堆 
priority_queue<int> pq;大根堆
pq.push(-x);小根堆
priority_queue<int, vector<int>, greater<int> > pq;小根堆


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

C.priority_queue中的函数
1. pq.push(item)：在 pq 中添加⼀个元素 O(logn)
2. pq.top()：获取 pq 最大的元素 O(1)
3. pq.pop()：使 pq 中最大的元素出队 O(logn)
4. pq.size()：获取 pq 中元素个数 O(1)
5. pq.empty()：判断 pq 是否为空 O(1)

四.set

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

B.创建set类型
set<Type>s;
multiset<Type>s;
unorded_set<Type>s;
unorded_multiset<Type>s;
如果Type无法进行比较，还需要和优先队列一样定义<运算符

C.遍历set的方法
for(auto i:s)cout<<i<<" ";
和vector的类似

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

五.map

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

B.创建map
map<key, value> mp;
unordered_map<key, value>mp;

C.遍历map的方法
for(auto i:mp)
    cout<<i.first<<' '<<i.second<<endl;

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

六.pair
pair<int,string> pa;
sort(pa.begin(),pa.end());
pa.first
pa.second

pa=make_pair(10,"vufkf");
pa={2.,"dybsv"};

三个元素，类似结构体
pair<int ,pair<int,string>>

七.unordered

unordered的作用
set和map都可以在前面加上unorder_使得内部的元素改成不按顺序存储的，其余的功能都不改变，虽然无法顺序存储，但底层原理是hash，可以使得所有的查询、修改、删除操作都变成O(1)复杂度

八.bitset

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

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

九.常用函数

A.
▸ max(val1, val2)：返回更⼤的数
▸ min(val1, val2)：返回更⼩的数
▸ swap(type, type)：交换两者的值，可以是两个值也可以是两个STL的容器

B.
sort(first, last, compare)
▸ first：排序起始位置（指针或 iterator）
▸ last：排序终⽌位置（指针或 iterator）
▸ compare：⽐较⽅式，可以省略，省略时默认按升序排序，如果排序的元素没有定义比较运算（如结构体），必须有compare
▸ sort 排序的范围是 [first, last)，时间为 O(nlogn)
#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);//[a[0],a[5])==[a[0],a[4]]sort 排序的范围是 [first, last)
    sort(arr,arr+5,greater<int>());//降序排列greater<int>()
    sort(arr,arr+5,cmp);//降序cmp
    sort(arr,arr+5,[](int a,int b){return a>b;});//降序排列[](int a,int b){return a>b;}
    return 0;
}

C.
unique(first, last)：
▸ [first, last)范围内的值必须是一开始就提前排好序的
▸ 移除 [first, last) 内连续重复项
▸ 去重之后的返回最后一个元素的下一个地址（迭代器）
#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;
}

D.
二分函数（lower_bound/upper_bound）
lower_bound(first, last, value)
▸ first：查找起始位置（指针或 iterator）
▸ last：查找终⽌位置（指针或 iterator）
▸ value：查找的值
▸ lower_bound 查找的范围是 [first, last)，返回的是序列中第⼀个大于等于 value 的元素的位置，时间为 O(logn)
▸ [first, last)范围内的序列必须是提前排好序的，不然会错
▸ 如果序列内所有元素都⽐ value ⼩，则返回last
upper_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;
}

E.
next_permutation(first, last)
用于求序列[first,last)元素全排列中一个排序的下一个排序
#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;
}

在这里插入图片描述

阿斯卡码

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
C++ STL

STL 是⼀个 C++ 软件库，⾥⾯包含算法（algorithms）、容器（containers）、函数（functions）、迭代器（iterators）创建string类型变量string s; 直接创建一个空的（大小为0）的string类型变量sstring s=*char; 创建string时直接用字符串内容对其赋值，注意字符串要用双引号""string s(int n,char c); 创建一个string，由n个c组成，注意c是字符型要用单括号''读入stringcin>&g
复制链接

扫一扫