C++常用stl

C++常用STL

一、vector

声明：

头文件：#include <vector>
定义：vector<数据类型> a;
初始化： vector<int> v(n,0) //定义全为0而且长度为n的数组
方法：
	不能用 '=='运算符比较两个vector
	size/empty 通用的,返回长度和是否为空(空返回1，非空返回0)
	v.clear()清空v中的元素 O(size)
	v.resize(int n)把v的长度设定为n个元素 O(n)
	v.front()  取出首元素
	v.back()   取出末尾元素
	v.begin()  返回首迭代器，指向第一个元素O(1)
	v.end()    返回尾迭代器，指向向量最后一个元素的下一个位置O(1)
	v.push_back()     增
	v.pop_back()       删
	v.insert()   由于insert重载方法比较多
	   1.v.insert(p,t)  将t插到下标p的前面
	   2.v.insert(p,n,t) 将n个t插入下标p之前
	   3.v.insert(p,i,j) 将区间[i,j)的元素插入到下标p之前
	v.erase(t,k)
	   1.v.erase(t,k) 删除[t,k)他们之间的元素
	   2.v.erase(p) 删除下标p指向的元素
	v.reverse()  反转vector

创建指定大小的二维vector：

int rows = 3;
int columns = 4;
int initial_value = 0;
vector<vector<int>> g(rows, vector<int>(columns, initial_value));

邻接表存图(无权值)

void addEdge(int u, int v){
	g[u].push_back(v);
	g[v].push_back(u);
}
vector<vector<int>> g(N);

邻接表存图(有权值)

//定义边
struct edge{
	int to;  //目标节点
	int w;  //权值
	edge(int a, int b) : to(a),w(b) {}
};
vector<vector<edge>> g[N];
//存边
void addEdge(int u, int v, int w){
	g[u].emplace_back(v, w);
	g[v].emplace_back(u, w);
}
//初始化
	for(int i=1; i<=n; i++)
		g[i].clear();
检索点u的所有邻居
	for(int i=0; i<g[u].size(); i++){
		cout << g[i].to << endl;
		cout << g[i].w << endl;
	}

二、queue

声明：

头文件:#include <queue> 
	  #include <vector>(用到优先队列)
定义: queue<int> q;

使用方法：

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

优先队列：

创建方法：

priority_queue<Type, Container, Functional> q; (大根堆)
priority_queue<int,vector<int>,greater<int>> q; (小根堆)
priority_queue<pair<int, int>, vector<int>,greater<int>> q (带pair的小根堆)
// Type:数据类型
// Container:存放数据的容器，默认用的是 vector
//Functional：元素之间的比较方法，当type可以比较时后两个可以省略

使用方法:

q.push(item)：在q中添加一个元素 O(logn)
q.pop()：使q中最大的元素出队 O(logn)
q.top()：获取q最大的元素 O(1)
q.size()：获取q中元素个数 O(1)
q.empty()：判断q是否为空 O(1)

重载小于运算符

#include <bits/stdc++.h>

using namespace std;

struct rec{
	int id;
	double value;
};
bool operator <(const rec &a, const rec &b){
	return a.value > b.value; (大于就是小根堆)
}


int main(){
	priority_queue<rec> pq;
	pq.push({1,3.0});
	pq.push({3,2.0});
	pq.push({2,1.0});
 	while(!pq.empty()){
        cout<<pq.top().id<<' '<<pq.top().value<<endl;
        pq.pop();
    }
    return 0;
}

三、string

读入string

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

常用函数

s[index]返回字符串s中下标为index的字符，String中下标也是从0开始 O(1)
s.substr(p,n)返回从s的下标p开始的n个字符组成的字符串，如果n省略就取到底 O(n)
s.back() 返回末尾元素
s.clear() 清空字符串内容
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.insert(p0,s2,pos,len) 后两个参数截取s2,可以省略 O(n)
s.insert(p0,n,c) 在p0处插入n个字符c 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)

四、map

声明

头文件： #include <map>
map<key_type, value_type, Functional> name;
遍历map得到的是一个双元组。
map<vector<int>,pair<int,int>> test;

map遍历

1. auto

for(const auto& v : name)
    cout << v.first << ' ' << v.second << endl;

2.for

map<int, int>::iterator iter;
for(iter = _map.begin(); iter != _map.end(); iter++) 
{
    cout << iter->first << ' ' << iter->second << endl;
}

map的重载排序

#include <iostream>
#include <map>
#include <string>

using namespace std;

struct StringLengthComparator {
    bool operator()(const string& lhs, const string& rhs) const {
        return lhs.length() > rhs.length(); //(长的优先)
    }
};

int main() {
    map<string, int, StringLengthComparator> myMap;

    myMap["apple"] = 1;
    myMap["banana"] = 2;
    myMap["carrot"] = 3;
    myMap["dragonfruit"] = 4;

    // 遍历输出键值对，按照字符串长度排序
    for (const auto& pair : myMap) {
        cout << pair.first << " : " << pair.second << endl;
    }

    return 0;
}
/*
dragonfruit : 4
banana : 3
apple : 1
*/

使用方法

1.size/empty/begin/end  大小/是否为空/头迭代器/尾迭代器
2.insert/erase 插入和删除的参数是pair<key_type,value_type>
	myMap.insert({key_type,value_type}) or myMap.insert(make_pair(key_type,value_type))
	myMap.erase(key_type);
3.find(x) 在myMap中查找key为x的二元组，不存在返回end()。
4.[]操作符 h[key]是赋值，如果不在h里面的话会自动生成二元组(key,zero)。

find操作：

#include <iostream>
#include <map>

int main() {
    std::map<int, std::string> myMap;

    myMap[1] = "apple";
    myMap[2] = "banana";
    myMap[3] = "carrot";

    // 使用 find() 查找键为 2 的元素
    auto it = myMap.find(2);

    // 检查是否找到了元素
    if (it != myMap.end()) {
        std::cout << "Element found: " << it->first << " : " << it->second << std::endl;
    } else {
        std::cout << "Element not found." << std::endl;
    }

    return 0;
}

输出：Element found: 2 : banana

五、set

声明:

#include <set>
set<int> s[N];

迭代器遍历：

#include <iostream>
#include <set>

int main() {
    std::set<int> mySet = {3, 1, 4, 1, 5}; // 创建一个包含一些整数的 set

    // 使用迭代器遍历 set
    for (auto it = mySet.begin(); it != mySet.end(); ++it) {
        std::cout << *it << " "; // 输出当前迭代器指向的元素
    }
    std::cout << std::endl;
    return 0;
}

// 1 3 4 5

auto遍历：

#include <iostream>
#include <set>

int main() {
    std::set<int> mySet = {3, 1, 4, 1, 5}; // 创建一个包含一些整数的 set

    // 使用范围-based for 循环遍历 set
    for (const auto& element : mySet) {
        std::cout << element << " "; // 输出当前元素
    }
    std::cout << std::endl;

    return 0;
}

// 1 3 4 5

常用函数：

size/empty/clear/begin/end
find(x):返回指向该元素x的迭代器，若不存在返回end() O(logn)
insert(x):x插入到set中，若存在则不会插入 O(logn)
erase(x): 删除所有等于x的元素， O(k+logn) k为被删除的元素个数
count(x): 返回集合中等于x的元素个数，O(k+logn) k为元素x的个数

set的重载排序：

#include <iostream>
#include <set>
#include <string>

struct Person {
    std::string name;
    int age;
};
// 定义小于号运算符
bool operator <(const Person &a, const Person &b){
    return a.age < b.age; // 根据年龄进行比较
}

int main() {
    std::set<Person> personSet;

    personSet.insert({"Alice", 25});
    personSet.insert({"Bob", 30});
    personSet.insert({"Charlie", 20});

    // 遍历 set
    for (const auto& person : personSet) {
        std::cout << "Name: " << person.name << ", Age: " << person.age << std::endl;
    }

    return 0;
}
/*
Name: Charlie, Age: 20
Name: Alice, Age: 25
Name: Bob, Age: 30
*/

六、deque

声明：

#include<deque>
deque<int> q;

常用方法：

[]:随机访问，相当于vector
begin/end: 头/尾迭代器
front/back: 返回队头/队尾元素
push_back: 从队尾入队
push_front: 从队头入队
pop_back: 从队尾出队
pop_front: 从队头出队
clear: 清空队列

七、bitset

声明：

#include <bitset>
n位bitset执行一次位运算的复杂度可视为 n/32。
bitset<10000> s;
表示一个10000位二进制数，<>中填写位数。

常用函数：

位运算操作符：
~s:返回bitset s 所有位的按位取反的结果(返回一个bitset)
&,|,^:返回对两个位数相同的bitset执行按位与、或、异或运算的结果(返回一个bitset)
>>,<< 返回一个把bitset右移、左移、若干位的结果 bits >>= n;(返回bits)
==,!=: 比较两个bitset代表的二进制位数是否相等。
[]操作符：既可以取值也可以赋值
s.size(): 返回bitset中位的数量
count():返回有多少位为1
s.set(): 所有位设置为1
s.set(k, v): 即s[k] = v;
s.reset: 所有为设置为0
s.reset(k): 即s[k] = 0;
s.flip: s所有位取反
to_string(): 将位集合转换为字符串表示形式

八、pair

pair相当于存储一个二元组。
排序时会默认按第一个元素升序排序。
可以嵌套。
具体使用方法( )：

声明： #include <utility>
pair<int, int> tone;//定义二元组
pair<int, pair<int, int>> ttwo;//定义三元组
pair<int, int> tthree[10086];//定义pair数组
cout << tone.first << endl;//查看tone的第1项。
cout << tone.second << endl;//查看tone的第二项
cout << ttwo.second.second << endl;//循环嵌套

数组嵌套pair

#include <iostream>
#include <utility>

const int ROWS = 1000;

int main() {
    std::pair<int, std::string> nestedArray[ROWS];

    for (int i = 0; i < ROWS; i++) {
            int firstValue;
            std::string secondValue;

            scanf("%d", &firstValue);
            scanf("%s", secondValue);  // 假设输入的是字符串，以空格为分隔符

            nestedArray[i] = std::make_pair(firstValue, secondValue);
    }

    // 输出验证
    for (int i = 0; i < ROWS; i++) {
            std::cout << nestedArray[i].first << ": " << nestedArray[i].second << std::endl;
    }

    return 0;
}

数组嵌套pair排序(以第一个元素为基准升序排序)：

#include <iostream>
#include <algorithm>
#include <utility>

bool comparePairs(const std::pair<int, std::string>& pair1, const std::pair<int, std::string>& pair2) {
    return pair1.first < pair2.first; // 根据 pair 的第一个元素进行升序排序
}

int main() {
    const int SIZE = 3;
    std::pair<int, std::string> arr[SIZE];

    arr[0] = std::make_pair(3, "Apple");
    arr[1] = std::make_pair(1, "Banana");
    arr[2] = std::make_pair(2, "Carrot");

    // 对数组进行排序
    std::sort(arr, arr + SIZE, comparePairs);

    // 输出排序后的数组
    for (int i = 0; i < SIZE; i++) {
        std::cout << arr[i].first << ": " << arr[i].second << std::endl;
    }
    
    /*
    1: Banana
	2: Carrot
	3: Apple
	*/
    return 0;
}