vector a; // 相当于一个长度动态变化的int数组
vector b[233]; // 相当于第一维长233，第二位长度动态变化的int数组
struct rec{…};
vector c; // 自定义的结构体类型也可以保存在vector中
##### 11.1.2 size/empty
* size函数返回vector的实际长度（包含的元素个数）
* empty函数返回一个bool类型，表明vector是否为空。
* 二者的时间复杂度都是 O(1)。
所有的STL容器都支持这两个方法，含义也相同，之后我们就不再重复给出。
##### 11.1.3 clear
clear函数把vector清空。
>
> 除了队列，优先队列和栈之外，其他都有clear函数
>
>
>
a.clear//把当前数组清空
##### 11.1.4 迭代器
迭代器就像STL容器的“指针”，可以用星号\*操作符解除引用。
一个保存int的vector的迭代器声明方法为：
vector::iterator it;
//如果想取值的话，使用
*it //当作指针来看即可
vector的迭代器是“随机访问迭代器”，可以把vector的迭代器与一个整数相加减，其行为和指针的移动类似。可以把vector的两个迭代器相减，其结果也和指针相减类似，得到两个迭代器对应下标之间的距离。
##### 11.1.5 begin/end
* begin函数返回指向vector中第一个元素的迭代器。
>
> 例如a是一个非空的vector，则\*a.begin()与a[0]的作用相同。
>
>
>
* 所有的容器都可以视作一个“前闭后开”的结构，end函数返回vector的尾部，即第n 个元素再往后的“边界”。
* 简而言之，end就是最后一个元素的下一个。
>
> \*a.end()与a[n]都是越界访问，其中n = a.size()。
>
>
>
下面两份代码都遍历了vector<int> a，并输出它的所有元素。
for (int i = 0; i < a.size(); i ++)
cout << a[i] << endl;
for (vector::iterator it = a.begin(); it != a.end(); it ++)
cout << *it << endl;//相当于取值
//此外vector还有范围遍历，类似于string
for(int x : a)cout << x << endl;
##### 11.1.6 front/back
* front函数返回vector的第一个元素，等价于\*a.begin()和a[0]。
* back函数返回vector的最后一个元素，等价于\*–a.end()和a[a.size() – 1]。
##### 11.1.7 push\_back()和pop\_back()
* a.push\_back(x)把元素x插入到vector a的尾部。
* b.pop\_back()删除vector a的最后一个元素。
#### 11.2 #include <queue>
头文件queue主要包括循环队列queue和优先队列priority\_queue两个容器。
优先队列：会优先弹出所有数的最大值。
##### 11.2.1 声明
queue q;
struct rec{…}; queue q; //结构体rec中必须定义小于号（重载小于号）
priority_queue q; // 大根堆
priority_queue<int, vector, greater> q; // 小根堆
priority_queue<pair<int, int>>q; //二元组
struct Rec
{
int a,b;
bool operator < (const Rec& t)const
{
return a < t.a;
}
};
priority_queue d;
d.push({1, 2});
##### 11.2.2 循环队列queue
队尾插入，队头弹出
* push // 从队尾插入
* pop // 从队头弹出
* front // 返回队头元素
* back // 返回队尾元素
queue q;
q.push(1);
q.pop();
q.front;
cout << q.back() <<endl;
##### 11.2.3 优先队列priority\_queue
push // 把元素插入堆
pop // 删除堆顶元素
top // 查询堆顶元素（最大值）
priority_queue a;
a.push(1);
a.pop();//删除最大值
a.top();//查询最大值
//由于没有clear函数，因此如果想要清除的话，重新初始化一个队列即可
q = queue();
#### 11.3 #include <stack>
头文件stack包含栈。声明和前面的容器类似。
push // 向栈顶插入
pop // 弹出栈顶元素
#include
using namespace std;
int main()
{
stack stk;
stk.push(1);
stk.top();
stk.pop();
return 0;
}
#### 11.4 #include <deque>
双端队列deque是一个**支持在两端高效插入或删除元素的连续线性存储空间**。
它就像是vector和queue的结合。与vector相比，deque在头部**增删元素仅需要 O(1)的时间**；与queue相比，deque像数组一样支持随机访问。
运行效率不如前面几者。
* [] // 随机访问
* begin/end // 返回deque的头/尾迭代器
* front/back // 队头/队尾元素
* push\_back // 从队尾入队
* push\_front // 从队头入队
* pop\_back // 从队尾出队
* pop\_front // 从队头出队
* clear // 清空队列
#include
using namespace std;
int main()
{
deque a;
a.begin();a.end();
a.front();a.back();
a.push\_back(1),a.push\_front(2);
a[0];
a.pop\_back(),a.pop\_front();
a.clear;
return 0;
}
#### 11.5 #include <set>
头文件set主要包括set和multiset两个容器，分别是“有序集合”和“有序多重集合”，即前者的元素不能重复，而后者可以包含若干个相等的元素。
set和multiset的内部实现是一棵红黑树，它们支持的函数基本相同。
##### 11.5.1 声明
set s;
struct rec{…}; set s; // 结构体rec中必须定义小于号
multiset s;
#include
using namespace std;
int main()
{
set a;
multiset b;
struct Rec
{
int x,y;
bool operater < (const Rec& t)const
{
return x < t.x;
}
};
set<Rec> c;
}
##### 11.5.2 size/empty/clear
与vector类似
##### 11.5.3 迭代器
set和multiset的迭代器称为“双向访问迭代器”，不支持“随机访问”，支持星号\*解除引用，仅支持++和–两个与算术相关的操作。(找该节点的前驱或者后继)
设it是一个迭代器，例如set::iterator it;
若把it ++，则it会指向“下一个”元素。这里的“下一个”元素是指在元素从小到大排序的结果中，排在it下一名的元素。同理，若把it --，则it将会指向排在“上一个”的元素。
##### 11.5.4 begin/end
返回集合的首、尾迭代器，时间复杂度均为 O(1)。
s.begin()是指向集合中最小元素的迭代器。
s.end()是指向集合中最大元素的下一个位置的迭代器。换言之，就像vector一样，是一个“前闭后开”的形式。因此-- s.end()是指向集合中最大元素的迭代器。
##### 11.5.5 insert
s.insert(x)把一个元素x插入到集合s中，时间复杂度为 O(logn)。
在set中，若元素已存在，则不会重复插入该元素，对集合的状态无影响。
##### 11.5.6 find
s.find(x)在集合s中查找等于x的元素，并**返回指向该元素的迭代器**。
若不存在，则返回s.end()。时间复杂度为 O(logn)。
因此可以通过这个性质判断x在a中是否存在。
if(a.find(X) == a.end())
##### 11.5.7 lower\_bound/upper\_bound
这两个函数的用法与find类似，但查找的条件略有不同，时间复杂度为 O(logn)。两个二分查找。
s.lower\_bound(x)查找**大于等于x**的元素中**最小的一个**，并返回指向该元素的迭代器。
s.upper\_bound(x)查找**大于x**的元素中**最小的一个**，并返回指向该元素的迭代器。
##### 11.5.8 erase
设it是一个迭代器，s.erase(it)从s中删除迭代器it指向的元素，时间复杂度为 O(logn)。
设x是一个元素，s.erase(x)从s中删除所有等于x的元素，时间复杂度为 O(k+logn)，其中 k 是被删除的元素个数。
##### 11.5.9 count
s.count(x)返回集合s中等于x的元素个数，时间复杂度为 O(k+logn)，其中 k 为元素x的个数。
>
> 对于set来讲，不存在重复的元素，因此如果结果为1，代表存在，为0代表不存在。
>
>
>
#### 11.6#include <map>
**map容器是一个键值对key-value的映射**，其内部实现是一棵以key为关键码的红黑树。Map的key和value可以是任意类型，其中key必须定义小于号运算符。
可以像用数组一样用其他的变量。
##### 11.6.1 声明
map<key_type, value_type> name;
//例如：
map<long, long, bool> vis;
map<string, int> hash;
map<pair<int, int>, vector> test;
#include
##### 11.6.2 size/empty/clear/begin/end
均与set类似。
##### 11.6.3 insert/erase
与set类似，但其参数均是pair<key\_type, value\_type>。
##### 11.6.4 find
h.find(x)在变量名为h的map中**查找key为x**的二元组。
cout << ( a.find(“timerring”) == a.end()) <<endl;
s.find(x)在集合s中查找等于x的元素，并**返回指向该元素的迭代器**。
##### 11.6.5 []操作符
h[key]返回key映射的value的引用，**时间复杂度为 O(logn)**。
[]操作符是map最吸引人的地方。我们可以很方便地通过h[key]来得到key对应的value，还可以对h[key]进行赋值操作，改变key对应的value。
#### 11.7 #include<unordered\_set>
由于是无序的set，因此没有lower/upper\_bound，其他基本与set一致。
其余所有函数都是O（1）的复杂度，因此相较于set更加高效。
#include<unordered_set>
using namespace std;
int main()
{
unordered_set a;//哈希表，不能存储重复元素
unordered_multiset b; //哈希表，可以存储重复元素
return 0;
}
#### 11.8 #include<unordered\_map>
也是一个哈希表，好处是它的效率更高。需要在C++10中才能支持。
#include<unordered_set>
using namespace std;
int main()
{
unordered_map<int,int > a;//哈希表，不能存储重复元素
return 0;
}
#### 11.9 #include<bitset>
#include
using namespace std;
int main()
{
bitset<1000> a;//长度为1000位的01串
a[0] = 1;
a[1] = 1;
//可以做位运算
扫一扫
1277
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
