AcWing C++语法笔记第八节STL容器

1、该系列为ACWing中c++语法课，已购买正版，课程作者为yxc（请大家支持正版）。
2、为啥写在这儿，问就是oneNote的内存不够了QAQ

0、简介

容器（STL）是存数据的东西，string /vector 都是容器。
STL是提高C++编写效率的一个利器。

一、 vector容器

vector是变长数组（可以自动改变长度的数组），支持随机访问，不支持在任意位置 O(1) 插入。为了保证效率，元素的增删一般应该在末尾进行。

例如：开最大长度为10,0000的数组，个数小于等于10,0000，数组总长度小于等于100,0000。如果用数组定义则为 int q[100000][100000]需要40G的空间。因此我们需要vector用多少开多少空间。

1.1 声明

#include <vector>   // 头文件

using namespace std;

vector<int> a;      // 相当于一个长度动态变化的int数组
vector<int> b[233]; // 相当于第一维长233，第二位长度动态变化的int数组

struct rec{
	int x, y;
};    
vector<rec> c;      // 自定义的结构体类型也可以保存在vector中

1.2 size/empty

size函数返回vector的实际长度（包含的元素个数），empty函数返回一个bool类型，表明vector是否为空。二者的时间复杂度都是 O(1)。

vector<int> a;  
a.size();
a.empty();

所有的STL容器都支持这两个方法，含义也相同，之后我们就不再重复给出。

1.3 clear

clear函数把vector清空(vector特有)。

vector<int> a;  
a.clear();

1.4 迭代器

迭代器就像STL容器的“指针”（或循环变量，但循环变量是数组下标），可以用星号*操作符解除引用。
一个保存int的vector的迭代器声明方法为：

vector<int> a; 
vector<int>::iterator it = a.begin();

it   //相当于访问a[0]
it+2 //相当于访问a[2]

*it //取迭代器的值

a.begin()是a的起始迭代器。

vector的迭代器是“随机访问迭代器”，可以把vector的迭代器与一个整数相加减，其行为和指针的移动类似。可以把vector的两个迭代器相减，其结果也和指针相减类似，得到两个迭代器对应下标之间的距离。

1.5 begin/end

所有的容器都可以视作一个“前闭后开”的结构。

begin和end是两个特殊的迭代器。

begin函数返回指向vector中第一个元素的迭代器（返回第一个元素的地址）。例如a是一个非空的vector，则*a.begin()与a[0]的作用相同。

end函数返回vector的尾部，即第n个元素再往后的“边界”（最后一个位置的下一个位置）。*a.end()与a[n]都是越界访问，其中n = a.size()。

下面两份代码都遍历了vector<int> a，并输出它的所有元素。

#include <iostream>
#include <vector>

using namespace std;

int main(){
//初始化
vector<int> a({1, 2, 3});

cout << a[0] << ' '<< *a.begin()) << endl; //查看这两个值是否相同；

//遍历
for (int i = 0; i < a.size(); i ++)
    cout << a[i] << ' ';
cout << endl;

for (vector<int>::iterator it = a.begin(); it != a.end(); it ++)
//for (auto it = a.begin(); it != a.end(); it ++)
    cout << *it << ' ';
cout << endl;

for (int x:a) cout << x << ' ';
cout << endl;
}

1.6 front/back

front函数返回vector的第一个元素，等价于*a.begin()和a[0]。
back函数返回vector的最后一个元素，等价于*-- a.end()和a[a.size() – 1]。

vector<int> a({1, 2, 3});
cout << a.front() << ' '<< a[0] <<' '<< *a.begin()<< endl;
cout << a.back() << ' ' <<a[a.size()-1] << endl;

1.7 push_back()和pop_back()

a.push_back(x)把元素x插入到vector a的尾部，时间复杂度为O(1)（但是再数组开头插入和删除是O(N)）。
a.pop_back()删除vector a的最后一个元素。

vector<int> a({1, 2, 3});
a.push_back(4);
for(auto x:a) cout << x <<' ';
cout << endl;

a.pop_back();
for (auto x:a) cout << x << ' ';
cout << endl;

1.8 动态扩展空间

vector基于倍增的思想动态扩展空间。
假设首先开长度为10的数组，并写入元素。当加入第11个时，数组就不够用了。接着开长度为20的数组，并将前10个数字复制过来。当20个还是不够时，会开一个长度40的数组。

如果插入$n$个数，那么会拷贝 $n/2(第一次)+n/4(第二次)+n/8+...=n(1/2+1/4+1/8+...)<n$ 的次数(即拷贝数组的平均次数小于n，平均每次为O(1))

vector的速度基本比数组慢一倍。

1.9 比较运算

按照字典序

vector<int> c,d;
if(c==d)...
if(c<d) ...

二、 queue队列

头文件queue主要包括循环队列queue和优先队列priority_queue（实时返回所有数里面的最大值）两个容器。

队列是用堆实现的。

2.1 声明

#include <queue>									//头文件

queue<int> q;										//队列的定义

struct rec{
	int a;
}; 
queue<rec> q;                        				//结构体rec中必须定义小于号

//优先队列的定义
priority_queue<int> q;                              // 大根堆（返回最大值）
priority_queue<int, vector<int>, greater<int>> q;   // 小根堆（返回所有数的最小值）
priority_queue<pair<int, int>>q;					// pair二元组的数据结构

//定义结构体类型的优先队列（大根堆必须重载小于号）
struct Rec{
	int a, b;
	bool operator< (const Rec& t) const
	{
		return a < t.a;
	}
}; 
priority_queue<Rec> d;   
d.push({1, 2});


//定义结构体类型的优先队列（小根堆必须重载大于号）
struct Rec{
	int a, b;
	bool operator> (const Rec& t) const
	{
		return a > t.a;
	}
}; 
priority_queue<Rec, vector<Rec>, greater<Rec>> d;   
d.push({1, 2});

队列的性质是：先进先出

优先队列：维护的是没有序的队列，每次弹出所有数的最大值。

pair是一个二元组，可以是任意类型，支持比较运算（双关键字比较）。

pair<int, string> a, b;
a = {3, "yxc"};       						// 构造方式；
cout << a.first << ' ' << a.second << endl; // 输出；

a = make_pair(4, "abc");					//c++99中需要的赋值方式
cout << a.first << ' ' << a.second << endl;

if(a<b)...

2.2 循环队列queue

循环队列：循环队列就是普通队列，队列长度和队列中现存元素数量相关，和插入的次数无关。

queue<int> q;	

q.push(1);    // 从队尾插入
q.pop();      // 从队头弹出
q.front();    // 返回队头元素
q.back();     // 返回队尾元素

注意：循环队列和优先队列、栈是没有clear()函数的（其他容器都有）；

清空队列的方法：重新初始化。

q = queue<int>();

2.3 优先队列priority_queue

priority_queue<int> q; 

q.push(1);    // 把元素插入堆（位置不确定）
q.pop();     // 删除堆顶元素
q.top();     // 查询堆顶元素（最大值）

三、栈stack

头文件stack包含栈。声明和前面的容器类似，只是先进后出。

函数调用的栈只是逻辑上是栈，实际是用汇编实现的。

#include <stack>

stack<int> stk;
stk.push(1);   // 向栈顶插入
stk.pop();     // 弹出栈顶元素

四、双端队列 deque

双端队列deque是一个支持在两端高效插入或删除元素的连续线性存储空间（可以在对队尾和队头都进行插入和弹出）。它就像是vector和queue的结合。与vector相比，deque在头部和尾部增删元素仅需要 O(1) 的时间；与queue相比，deque像数组一样支持随机访问。但是，双端队列的平均运行效率要比vector慢。

#include <deque>

deque<int> a;   // 定义

a[i];              		  // 随机访问一个元素
a.begin(), a.end();       // 返回deque的头/尾迭代器
a.front(), a.back();      // 队头/队尾元素
a.push_back(1);       	  // 从队尾入队
a.push_front(1);      	  // 从队头入队
a.pop_back();        	  // 从队尾出队
a.pop_front();	          // 从队头出队
a.clear();	              // 清空队列

五、 set

头文件set主要包括set和multiset两个容器，分别是“有序集合”和“有序多重集合”，即前者的元素不能重复，而后者可以包含若干个相等的元素。set和multiset的内部实现是一棵红黑树（平衡树），它们支持的函数基本相同。

5.1 声明

set动态维护一个有序的序列。

#include <set>

set<int> s;					// 元素不能重复
multiset<double> s;			// 元素可以重复

struct rec{
	int x, y;
	bool operator< (const rec& t) const
	{
		return x<t.x;
	}
}; 
set<rec> c;  				// 结构体rec中必须定义小于号

5.2 size/empty/clear

与vector类似

5.3 迭代器

set和multiset的迭代器称为“双向访问迭代器”，不支持“随机访问”，支持星号*解除引用，仅支持++和--两个与算术相关的操作（找有序序列的下一个元素，即二叉树中当前点的前驱或后继节点）。

设it是一个迭代器，例如：

set<int> a;
set<int>::iterator it = a.begin; // 生成迭代器
it ++; 							 // 有序序列的下一个元素
it --;
++ it;
-- it;

若把it ++，则it会指向“下一个”元素。这里的“下一个”元素是指在元素从小到大排序的结果中，排在it下一名的元素。同理，若把it --，则it将会指向排在“上一个”的元素。

5.4 begin/end

返回集合的首、尾迭代器，时间复杂度均为 O(1)。

s.begin()是指向集合中最小元素的迭代器。

s.end()是指向集合中最大元素的下一个位置的迭代器（最后元素的后一个位置）。换言之，就像vector一样，是一个“前闭后开”的形式。因此-- s.end()是指向集合中最大元素的迭代器。

5.5 insert

s.insert(x)把一个元素x插入到集合s中，时间复杂度为 O(logn)。

在set中，若元素已存在，则不会重复插入该元素，对集合的状态无影响。

5.6 find

s.find(x)在集合s中查找等于x的元素，并返回指向该元素的迭代器。若不存在，则返回s.end()。时间复杂度为 O(logn)。

判断x是否在s里存在：if (s.find(x) == s.endl() )

5.7 lower_bound/upper_bound

这两个函数的用法与find类似，但查找的条件略有不同（类似于二分），时间复杂度为 O(logn)。

s.lower_bound(x)查找大于等于x的元素中最小的一个，并返回指向该元素的迭代器。

s.upper_bound(x)查找大于x的元素中最小的一个，并返回指向该元素的迭代器。

5.8 erase

删除迭代器。

s.erase()删除所有迭代器。

设it是一个迭代器，s.erase(it)从s中删除迭代器it指向的元素，时间复杂度为 O(logn)。

设x是一个元素，s.erase(x)从s中删除所有等于x的元素，时间复杂度为 O(k+logn)，其中 k是被删除的元素个数。

5.9 count

s.count(x)返回集合s中等于x的元素个数，时间复杂度为 O(k+logn)，其中 k 为元素x的个数（由于set是不重复的，那么存在x返回1，不存在则返回0）。

5.10 unordered_set

是一个无序的set，底层实现是哈希表，和set是完全一样的用法且时间复杂度为O(1)，只是没有lower_bound和upper_bound二分函数。

#include <unordered_set>
using namespace std;
int main()
{
	unordered_set<int> a;		// 不可以存储重复元素
	unordered_multiset<int> b;  // 可以存储重复元素

	return 0;
}

六、 map容器

map容器是一个键值对key-value的映射，其内部实现是一棵以key为关键码的红黑树（与set类似，但是用法不同）。Map的key和value可以是任意类型，其中key必须定义小于号运算符。

6.1 声明

#include <map>

map<key_type, value_type> name;

//例如：
map<int, int> a;
a[1] = 2;  			// 插入<1,2> 二元组；
a[100000000]= 3;
cout << a[100000000] << endl;

map<long, long, bool> vis;

map<string, int> hash;
hash["zxy"] = 2;
cout << hash["zxy"]<< endl;

map<string, vector<int>> b;
b["yxc"] = vector<int>();
cout << b["yxc"].size() << endl;
b["zzz"] = vector<int>({1,2,3,4});
cout << b["zzz"][2] << endl;
b.insert({"aaa",{}});			 //  使用insert插入<"a", {}>的二元组

map<pair<int, int>, vector<int>> test;

6.2 size/empty/clear/begin/end

均与set类似。

6.3 insert/erase

与set类似，但其参数均是pair<key_type, value_type>。

6.4 find

h.find(x)在变量名为h的map中查找key为x的二元组。注意find返回的是迭代器。

map<string, vector<int>> b;
cout << (b.find("yxc") == a.end()) << endl;  // 是否存在
cout << *b.find("yxc") << endl;				 // 找到对应的值

6.5 [] 操作符

h[key]返回key映射的value的引用，时间复杂度为 O(logn)。

[]操作符是map最吸引人的地方。我们可以很方便地通过h[key]来得到key对应的value，还可以对h[key]进行赋值操作，改变key对应的value。

6.6 unordered_map

和map相似且效率更高，map效率为O(logn)，unordered_map是O(1)，但不支持二分。

#include <unordered_map>
using namespace std;
int main()
{
	unordered_map<int, int> c;

	return 0;
}

七、bitset容器

bitset容器用于位运算，会定义一个很长的二进制串。

#include <bitset>

using namespace std;

int main()
{
	bitset<1000> a, b;   // 长度为1000位的01串
	a[0] = 1;		     // 赋值的是1， 没赋值的是0
	cout << a[0]<< endl;

	cout << a.count() << endl; // 返回1的个数

	a &= b;  // 位运算
	a |= b;

	a.set(3);    // 把第三位设成1;
	a.reset(3);  // 把第三位设成0;
	return 0;
}