1、该系列为ACWing中c++语法课,已购买正版,课程作者为yxc(请大家支持正版)。
2、为啥写在这儿,问就是oneNote的内存不够了QAQ
ACwing C++ 语法笔记8STL容器
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
n个数,那么会拷贝
n
/
2
(
第一次
)
+
n
/
4
(
第二次
)
+
n
/
8
+
.
.
.
=
n
(
1
/
2
+
1
/
4
+
1
/
8
+
.
.
.
)
<
n
n/2(第一次)+n/4(第二次)+n/8+... = n(1/2+1/4+1/8+...) < 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;
}