C++基础（2022.9.3）

STL容器

序列式容器

Vector【动态数组】

​ vector 是 $STL$ 提供的 内存连续的、可变长度 的数组数据结构。能够提供线性复杂度的插入和删除，以及常数复杂度的随机访问。

①vector a,b[N];：定义一个 $vector/vector$ 数组。

②vector a(t,n);：将前 $t$ 位赋值为 $n$。

vector<int> a(4,-3);//输出结果:-3 -3 -3 -3
1

front()：返回第一个数

back()：返回最后一个数

push_back()：向最后插入一个数

pop_back()：把最后一个数删掉

• 三种遍历方式

//迭代器遍历
for(vector<int>::iterator i=a.begin();i!=a.end();i++)cout<<*i<<" ";
for(auto i=a.begin();i!=a.end();i++)cout<<*i<<" ";
//auto遍历,C++11
for(auto x:a)cout<<x<<" ";
//size遍历
for(int i=0;i<a.size();i++)cout<<a[i]<<" ";
1
2
3
4
5
6
7

[]：随机访问，和数组一样。

• 在内存紧张，判断数组字典序，时间复杂度要求不高的时候可以使用。

deque【双端队列】

​ deque 是 $STL$ 提供的双端队列数据结构，能够提供线性复杂度的插入和删除，以及常数复杂度的随机访问。

front()：返回队首元素

back()：返回队尾元素

push_back()：向队尾插入元素

pop_back()：弹出队尾元素

puch_front()：向队首插入元素

pop_front：弹出队首元素

[]：随机访问，和数组一样。

关联式容器

set & multiset

​ set 是关联容器，含有键值类型对象的已排序集，搜索、移除和插入拥有对数复杂度。set 内部通常采用红黑树实现。平衡二叉树的特性使得 set 非常适合处理需要同时兼顾查找、插入与删除的情况。

（1）set：不能有重复元素，插入重复元素将会忽略。

（2）multiset：可以有重复元素，并记录重复个数。

• 插入删除

insert(x)：插入 x，具体区别看上面。

erase(x)：删除值为 x 的所有元素，返回删除元素的个数。

erase(pos)：删除迭代器为 pos 的元素。

erase(first,last)：删除迭代器在 $[first,last)$ 范围内的所有元素。

• 查找

find(x)：查找 x 返回迭代器，不存在返回 end()。

count(x)：返回某一个数的个数，set中只有 $0$ 和 $1$ 两种情况，multiset 有多个。

lower_bound(x)：返回大于等于 $x$ 的最小的数的迭代器，不存在返回end()。

upper_bound(x)：返回大于 $x$ 的最小的数的迭代器，不存在返回end()。

​ lower_bound(x) 和 upper_bound(x) 的时间复杂度为 $O(logn)$。algorithm 库中的 lower_bound(x) 和 upper_bound(x) 时间复杂度为 $O(n)$。

​ set 没有提供自带的 nth_element。使用 algorithm 库中的 nth_element 查找第 大的元素时间复杂度为 $O(n)$。

map & multimap

​ map 是有序键值对容器，它的元素的键是唯一的。搜索、移除和插入操作拥有对数复杂度。map 通常实现为红黑树。

​ mapmp其中，Key 是键的类型，T 是值的类型，例如 map,map

（1）mapmp：不会存在键相同的元素。

（2）multimap：允许多个元素拥有同一键。（没有访问方法，一般不用）

• 插入和删除

可以直接通过下标访问来进行查询或插入操作。例如 mp["Alan"]=100。

insert(pair)：插入的是一个 $pair$，例如 mp.insert(pair("Alan",100));。

erase(Key)：删除键值为 $Key$ 的所有元素，返回删除元素的数量。

erase(pos)：删除迭代器为 $pos$ 的元素。

erase(first,last)：删除迭代器在 $[first,last)$ 范围内的所有元素。

• 查找

find(X)：若容器内存在键值为 $x$ 的元素，返回该元素的迭代器。

count(x)：返回键值为 $x$ 的元素数量。

lower_bound()：返回大于等于 $x$ 的最小的数的迭代器。不存在返回end()。

upper_bound()：返回大于 $x$ 的最小的数的迭代器。不存在返回end()。

[]：随机选址，和数组一样。使用第一个变量查找第二个变量。时间复杂度是 $o(logn)$。

无序关联容器

​ 自 C++11 标准起，四种基于哈希实现的无序关联式容器正式纳入了 C++ 的标准模板库中，分别是：unordered_set，unordered_multiset，unordered_map，unordered_multimap。

​ 和上面类似，增删改查的时间复杂度是 $O(1)$。不支持lower_bound()/upper_bound()。迭代器的++，–。

容器适配器

stack【栈】

​ stack 是一种后进先出 (Last In, First Out) 的容器适配器，仅支持查询或删除最后一个加入的元素（栈顶元素），不支持随机访问，且为了保证数据的严格有序性，不支持迭代器。

• 定义

stack<TypeName> s;				//使用默认底层容器 deque，数据类型为 TypeName
stack<TypeName, Container> s;	//使用 Container 作为底层容器
stack<TypeName> s2(s1);			//将 s1 复制一份用于构造 s2
1
2
3

• 成员函数（复杂度均为常数）

top()：返回栈顶元素。

push(x)：向栈中插入元素 $x$。

pop()：弹出栈顶元素。

queue【队列】

​ std::queue 是一种先进先出 (First In, First Out) 的容器适配器，仅支持查询或删除第一个加入的元素（队首元素），不支持随机访问，且为了保证数据的严格有序性，不支持迭代器。

• 定义

queue<TypeName> q;				//使用默认底层容器 deque，数据类型为 TypeName
queue<TypeName, Container> q;	//使用 Container 作为底层容器
queue<TypeName> q2(q1);			//将 s1 复制一份用于构造 q2
1
2
3

• 成员函数（复杂度均为常数）

front：返回队首元素。

back()：返回队尾元素。

push(x)：向队列中插入元素 $x$。

pop()：弹出队头元素。

• 队列中没有clear函数，要想清空队列，只能重新构造。

q=queue<int>();
1

priority_queue【优先队列、堆】

• 定义

​ 可以多加两个参数将默认的大根堆定义为小根堆，还可以在存数的时候将 $x$ 存成 $-x$，这样也可以反着利用大根堆。头文件还是使用#include 。

//定义大根堆（默认）
priority_queue<int>heap;
//定义小根堆
priority_queue<int,vector<int>,greater<int>>heap;
1
2
3
4

priority_queue<TypeName> q;             // 数据类型为 TypeName
priority_queue<TypeName, Container> q;  // 使用 Container 作为底层容器
priority_queue<TypeName, Container, Compare> q;
// 使用 Container 作为底层容器，使用 Compare 作为比较类型

// 默认使用底层容器 vector
// 比较类型 less（此时为它的 top() 返回为最大值）
// 若希望 top() 返回最小值，可令比较类型为 greater
// 注意：不可跳过 Container 直接传入 Compare

// 从 C++11 开始，如果使用 lambda 函数自定义 Compare
// 则需要将其作为构造函数的参数代入，如：
auto cmp = [](const pair<int, int> &l, const pair<int, int> &r) {
  return l.second < r.second;
};
priority_queue<pair<int, int>,vector<pair<int, int> >,decltype(cmp)>pq(cmp);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 成员函数（访问堆顶为 $O(1)$，插入删除元素为 $O(logn)$）

top()：返回堆顶元素

push(x)：插入元素 $x$，并对堆进行排序。

pop()：弹出堆顶元素。PA

共有函数

=：有赋值运算符以及复制构造函数。

begin()：返回指向开头元素的迭代器。

end()：返回指向末尾的下一个元素的迭代器。end()不指向某个元素。

size()：返回容器内的元素个数，返回类型是 $unsignedint$，在使用的时候最后将其转化为 $int$。

max_size()：返回容器理论上能存储的最大元素个数。

empty()：返回容器是否为空、

swap()：交换两个容器。

clear()：清空容器。

== / != / < / > / <= / >=：按字典序比较两个容器的大小。（无顺序容器不支持< / > / <= / >=）

典题

set应用【删除最小的大于等于某个值的元素】

set<int>a;
int x;
set<int>::iterator it=a.lower_bound(x);
if(it==a.end()){
	//not found
}else{
	//找到元素，进行操作。
    a.erase(it);
}
1
2
3
4
5
6
7
8
9

bitset

​ bitset 是标准库中的一个存储 0/1 的大小不可变容器。严格来讲，它并不属于 STL。由于内存地址是按字节即 byte 寻址，而非比特 bit，一个 bool 类型的变量，虽然只能表示 0/1, 但是也占了 1 byte 的内存。

​ bitset 就是通过固定的优化，使得一个字节的八个比特能分别储存 8 位的 0/1。

• 定义

bitset<N>bs;
bitset<N>bs(x);//将 x 转化为二进制存入。
bitset<N>bs(str);//str为 01 串。
1
2
3

• 成员函数

支持各种位运算操作：①~，&，|，^；②>>，<<；③==，!=

[]：随机访问。

count()：返回有多少个1

any()：返回是否至少有一个1

none()：是否全为0。

set(k,v)：将第 $k$ 位变成 $v$。

set()：把所有位变成 $1$

rset()：把所有位变成 $0$。

flip()：等价于~

flip(k)：把第 $k$ 位取反。

• 使用一个 $10^4\times 10^4$ 的bool矩阵，要是使用bool将会需要使用 $10^8=100MB$ 的空间，但是题目的空间限制是 $64MB$ 这个时候就可以使用bitset。

pair

​ pair 是标准库中定义的一个类模板。用于将两个变量关联在一起，组成一个“对”，而且两个变量的数据类型可以是不同的。（①first：第一个元素②second：第二个元素）

​ 支持 $sort$ 排序：以 $first$ 为第一关键字，以 $second$ 为第二关键字。

• 定义

//中间可以使用不同的数据类型
pair<int,strging> p;
//构造一个二元组
p=make_pair(10,"abc");
p={20,"def"}//C++11
//甚至可以用pair存储三个属性
pair<int,pair<int,int>> p;
1
2
3
4
5
6
7

String

​ string 是在标准库 （注意不是 C 语言中的 库）中提供的一个类，本质上是 basic_string 的别称。

• 定义

string str1,str2="abc";
1

（2）size()/length()：字符串长度。（使用 size() 的时候注意转化为 int）

（3）empty()：判断是否为空。

（4）clear()：清空字符串。

（5）可以直接添加字符串

string str="abc";
str+="def";//str=abcdef
1
2

（6）substr(a,b)：截取字符串

​ 将字符串从下标 $a$ 开始截取 $b$ 个字符（字符串下标从 $0$ 开始），要是 $b$ 超出字符串长度则一直输出到字符串结束为止。substr(a)：直接从下标 $a$ 开始截取完整个字符串。

string str="abcdef";
string a=str.substr(1,3);
string b=str.substr(1,999);
string c=str.substr(3);
//a="bcd"
//b="bcdef"
//c="def"
1
2
3
4
5
6
7

（7）c_str()：字符串的起始地址

string str="abcdef";
printf("%s",str.c_str());
//相当于printf("%s",&str[0]);
1
2
3