C++ STL
Vector
-
向量，变长数组
-
用于初始数组容量不确定的情况
-
用邻接表实现图
一、使用方式
#include <vector>
using namespace std;
vector<typename> name;
二、访问方式
- 下标访问
- 使用迭代器iterator 访问
#include <vector>
using namespace std;
int main(){
Vector<int> v;
v.push(); //向数组中添加元素
...
//1.使用 下标访问
for(int i = 0;i<v.size();i++){
printf("%d",v[i]);
}
//2.使用 迭代器访问
for(vertor(int)::iterator it = v.begin();it!=v.end();it++){
printf("%d",*it);
}
}
三、常用函数
| 函数名 | 函数作用 | 时间复杂度 |
|---|---|---|
| push_back() | 在容器尾部添加元素 | O(1) |
| pop_back() | 在容器尾部删除元素 | O(1) |
| size() | 获取数组容量 | O(1) |
| clear() | 清空数组 | O(N) |
| insert（it，x） | 在迭代器it位置添加x元素 | O(N) |
| erase（it） erase（first,last） | 删除迭代器it位置的元素 删除 [first,last) 位置的元素 | O(N) |
Set
-
集合
-
内部自动有序
-
自动去重
一、使用方式
#include<set>
using namespace std;
set<typename> name;
二、访问方式
- 只支持 迭代器访问
#include<stdio.h>
#include<set>
using namespace std;
int main(){
set<int> s;
s.insert(12); //添加元素
...
for(set<int>:: iterator it = s.begin();it!=s.end();it++){
printf("%d",*it);
}
}
三、常用函数
| 函数名 | 函数作用 | 时间复杂度 |
|---|---|---|
| insert() | 向集合中插入元素 | O(N) |
| find() | 在集合中查询，返回对应迭代器 | O(logN) |
| size() | 获取集合大小 | O(1) |
| clear() | 清空集合 | O(1) |
| erase( it ) earse( value ) erase( first It,last ) | 删除迭代器所指向的数值 删除指定的数值 删除first It所指向到last地址的元素 | O(N) O(1) O(last-first) |
String
- 字符串
一、使用方式
#include<string>
string str;
二、访问方式
- 通过下标访问
- 通过迭代器访问
#include<stdio.h>
#include<string>
using namespace std;
int main(){
string str = "abcd";
//通过下标访问
for(int i= 0;i<str.size();i++){
printf("%c ",str[i]);
}
//通过 c_str() 装换为 字符数组 输出
printf("\n=====================\n");
printf("%s",str.c_str());
printf("\n=====================\n");
//通过迭代器
for (string::iterator it = str.begin(); it!=str.end();it++){
printf("%c",*it);
}
return 0;
}
三、常用函数
| 函数名 | 函数功能 | 时间复杂度 |
|---|---|---|
| operator( += ) | 将字符串拼接 | O(1) |
| compare operator ==、<、>、!= | 比较运算，比较规则是字典序 | O(1) |
| size() length() | 获取长度 | O(1) |
| insert( pos,string ) insert(it,it2,it3) | 在pos位置插入string 在it位置插入[it2,it3)区间字符 | O(N) |
| erase(i t ) erase(first,last) erase(pos,length) | 删除迭代器所指元素 删除 [ first , last )区间字符 删除从pos位置，删除length个字符 | O(N) |
| clear() | 清空字符串 | O(1) |
| substr(pos，len) | 截取字符串，返回从pos开始，长度为len的字符 | O(len) |
| find(str) | 判断是否为包涵str，若包涵返回第一次出现的位置 | O(nm) |
| replace(pos,len,str) | 将字符串从pos位置开始，将长度为len的字符替换为str | O(N) |
Map
- 映射
- 将任何类型映射到任何类型,在map中数据以key的字典序排序
- Map中键和值的都是唯一的，如果需要一个键对应多个值可参考multimap
一、使用方式
#include<map>
using namespace std;
map<typename,typename> name;
二、访问方式
- 通过下标访问
- 通过迭代器访问
#include <cstdio>
#include <map>
using namespace std;
int main(int argc, char const *argv[])
{
map<char,int> mp;
mp['c'] = 12;
mp['d'] = 13;
mp['a'] = 1;
mp['f'] = 43;
mp['g'] = 1;
//map中key唯一，后添加的会覆盖前面的值
mp['c'] = 121;
printf("%d\n",mp['c']);
for (map<char,int>::iterator it = mp.begin(); it!=mp.end(); it++)
{
//通过it->first访问key的值，通过it->second访问value的值
printf("%c: %d\t",it->first,it->second);
}
return 0;
}
三、常用函数
| 函数名 | 函数功能 | 时间复杂度 |
|---|---|---|
| find（key） | 返回键为key的映射的迭代器 | O(logN) |
| erase( it ) erase( key ) arase(first,last) | 删除单个元素 删除区间元素 | O(1) O(logN) O(last-first) |
| size() | 获取映射容量 | O(1) |
| clear() | 清空映射 | O(N) |
Queue
- 队列
- 先进先出
- 一般用于广度优先搜索（BFS）
一、使用方式
#include<queue>
using namespace std;
queue<typename> name;
二、访问方式
#include <cstdio>
#include <queue>
using namespace std;
int main(int argc, char const *argv[])
{
queue<int> q;
q.push(12);
q.push(13);
q.push(15);
//因为queue是一种先进先出表，所以使用 front() 访问队首元素，back()访问队尾
printf("%d\n",q.front());
printf("%d",q.back());
return 0;
}
三、常用函数
| 函数名 | 函数功能 | 时间复杂度 |
|---|---|---|
| push() | 将元素进队列 | O(1) |
| front() | 访问队首元素 | O(1) |
| back() | 访问队尾元素 | O(1) |
| size() | 获取队列大小 | O(1) |
| pop() | 将队首出队列 | O(1) |
| empty() | 判断队列是否为空 | O(1) |
Priority_queue
- 优先队列
- 底层使用堆来实现，每次队首都是优先级最大的元素 什么是堆？
一、使用方式
#include<queue>
using namespace std;
priority_queue<typename> q;
二、访问方式
#include <cstdio>
#include <queue>
#include <string>
using namespace std;
int main(int argc, char const *argv[])
{
priority_queue<int,vector<int>,greater<> > q;
q.push(1);
q.push(6);
q.push(3);
//同队列，有限队列只能使用 top() 来访问队顶首元素
printf("%d\n",q.top());
return 0;
}
三、调整优先级
基本数据类型
- 在优先队列中，基本数据类型默认优先级为：从大到小（char为字典序从大到小）
//以下两种表示无区别
priority_queue<int> q;
priority_queue<int,vector<int>,less<int> q;
- 第二种表达方式的第二个参数 vector 表示承载 堆 的容器
- 第三个参数是第一个参数 int 的比较类，less 表示数字越大优先级越大，可替换参数：greater 表示数字越小优先级越大
结构体
#include<queue>
#inclue<string>
using namespace std;
//1.直接在结构体中写比较函数
struct fruit{
string name;
int price;
//无参构造
fruit(){}
//有参构造
fruit(string _name,int _price){
name = _name;
price = _price;
}
//frieng : 友元
//将比较运算符重载,price 的价格优先级，price越大，优先级越高
friend bool operator < (fruit f1,fruit f2){
return f1.price < f2.price;
}
}
//2.在结构体外
//定义在结构体外同样适用于其他STL容器（set），重新定义优先级
struct cmp{
bool operator(fruit f1,fruit f2){
return f1.price < f2.price;
}
}
//重新定义了优先级后，便可以使用 下面参数 来定义
priority_queue<int,vector<int>,cmp> p;
四、常用函数
| 函数名 | 函数功能 | 时间复杂度 |
|---|---|---|
| push() | 将元素进队列 | O(logN) |
| top() | 访问队首元素 | O(1) |
| size() | 获取队列大小 | O(1) |
| pop() | 将队首出队列 | O(logN) |
| empty() | 判断队列是否为空 | O(1)* |
- 使用 top() 函数之前应该使用 empty() 函数判断容器是否为空，否则可能因为队空出现问题
Stack
-
栈
-
后进先出
-
用来模拟递归，防止栈内存的限制而导致程序出错
一、使用方式
#include<stack>
using namespace std;
stack<typename> name;
二、访问方式
#include <cstdio>
#include <stack>
using namespace std;
int main(int argc, char const *argv[])
{
stack<int> s;
s.push(12);
s.push(3);
//由于 栈 是一个先进后出表，所以只能使用 top() 访问队首元素
printf("%d", s.top());
return 0;
}
三、常用函数
| 函数名 | 函数功能 | 时间复杂度 |
|---|---|---|
| push() | 将元素 入栈 | O(1) |
| pop() | 将元素栈顶元素 出栈 | O(1) |
| top() | 获取栈顶元素 | O(1) |
| size() | 获取 栈 的容量 | O(1) |
| empty() | 判断栈是否为空 | O(1) |
algorithm常用函数
| 函数名 | 函数功能 |
|---|---|
| min(x,y) | 比较两个数的大小，返回较小的 |
| max(x,y) | 比较两个数大小，返回较大的 |
| abs() | 返回 整数 类型的绝对值 |
| swap(x,y) | 交换两个数的值 |
| reverse(p1，p2) | 可以将数组指针在 [p1,p2)间的元素反转 |
| next_permutation() | 返回一个序列全排列的下一个 序列 |
| fill ( first,last,val ) | 将数组或容器中任意一段区间赋相同值 |
| sort() | 将可比较元素的区间进行排序 |
| lower_bound(first，last，val) | 在一个 有序 的数组(容器)中，返回在 [ first,last )区间里第一个值大于等于 val 元素的位置（指针） |
| upper_bound() | 在一个 有序 的数组(容器)中，返回在 [ first,last )区间里第一个值大于 val 元素的位置（指针） |
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
