总结一下平时常用的vector的用法。
- 初始化
int a[3] = {10, 20, 30}; vector<int> v1; //{} vector<int> v2(3); //{0, 0, 0} vector<int> v3 {1, 2, 3, 4, 5}; //vector<int> v3 = {1, 2, 3, 4, 5}; vector<int> v4(3,10); //{10, 10, 10} vector<int> v5 = v3; //vector<int> v5(v3); vector<int> v6(v3.begin()+1, v3.end()); //vector<int> v6(&a[0], &a[3]);
- 二维数组初始化
//{{}} vector<vector<int>> vec1; //1 1 1 //1 1 1 vector<vector<int>> vec2(2, vector<int>(3,1)); //1 1 1 //2 3 4 vector<vector<int>> vec3 = {{1, 1, 1},{2, 3, 4}};
- 遍历
for(int i = 0; i < v3.size(); ++i){ cout << v3[i] << " "; } for(vector<int>::iterator it = v3.begin(); it != v3.end(); it++){ cout << *it << " "; } for(auto i:v3){ cout << i << " "; }
- 逆序遍历
for (auto it = v5.rbegin(); it != v5.rend(); it++){ cout << *it << " "; }
- 容器长度
v3.size();
- 获取容器第一个元素,最后一个元素
v3.front(); v3.back();
- 判断为空,1为空,0非空
v3.empty();
- 尾插/弹出
//v1{} v1.push_back(1); //{1} v1.push_back(2); //{1, 2} v1.push_back(3); //{1, 2, 3} v1.pop_back(); //{1, 2} v1.pop_back(); //{1} v1.pop_back(); //{}
- 插入
//v3{1, 2, 3, 4, 5} v3.insert(v3.begin()+1, 0); //{1, 2, 3, 4, 5}->{1, 0, 2, 3, 4, 5} v3.insert(v3.end(), 0); //{1, 0, 2, 3, 4, 5}->{1, 0, 2, 3, 4, 5, 0} v3.insert(v3.begin(), v4.begin(), v4.end()); //{1, 0, 2, 3, 4, 5, 0}->{10, 10, 10, 1, 0, 2, 3, 4, 5, 0}
- 合并
//v2{0, 0, 0} v4{10, 10, 10} v2.insert(v2.end(), v4.begin(), v4.end());//{0, 0, 0}->{0, 0, 0, 10, 10, 10}
- 删除
v3.erase(v3.begin()+4); //{10, 10, 10, 1, 0, 2, 3, 4, 5, 0}->{10, 10, 10, 1, 2, 3, 4, 5, 0} //erase()返回被删除的下一个元素迭代器,如果删除的是最后一个元素,则返回最后一个元素 //*v3.erase(v3.end()-1)=0 v3.erase(v3.end()-1); //{10, 10, 10, 1, 2, 3, 4, 5, 0}->{10, 10, 10, 1, 2, 3, 4, 5} v3.erase(v3.begin(), v3.begin()+3); //{10, 10, 10, 1, 2, 3, 4, 5}->{1, 2, 3, 4, 5}
- 清空
v2.clear(); //{0, 0, 0, 10, 10, 10}->{}
- 判断是否存在
//#include <algorithm> find(); vector<int>::iterator it = find(v3.begin(), v3.end(), 0); if(it != v3.end()){ //find it } else{ //not found }
- 排序
//升序 sort(v3.begin(), v3.end());// sort(v3.begin(), v3.end(), less<int>()); //降序 //#include<functional> greater<int>()从大到小, less<int>()从小到大 sort(v3.begin(), v3.end(), greater<int>()); //还可以自己定义比较函数 bool complare(int a,int b) { return a>b; } sort(v3.begin(), v3.end(), complare);
- 二级排序
bool complare(pair<int, int> l,pair<int, int> r) { return l.first != r.first ? l.first < r.first : l.second > r.second; } //第一个元素按从小到大排序,第二个则是从大到小 vector<pair<int, int>> vp{{1,1},{1,2},{2,2},{2,3},{3,3}};//{{1,1},{1,2},{2,2},{2,3},{3,3}}->{{1,2},{1,1},{2,3},{2,2},{3,3}} sort(vp.begin(), vp.end(), complare);
- 交换
//vector.swap(v)交换两个容器的内容 v1.swap(v3); // v1:{}->{5,4,3,2,1}, v3:{5,4,3,2,1}->{} swap(v1[0], v1[1]);// v1:{5,4,3,2,1}->{4,5,3,2,1}
vector方法表格,引自https://github.com/huihut/interview/tree/master/STL#vector
方法 | 含义 |
---|---|
vector | 构造函数 |
~vector | 析构函数,销毁容器对象 |
operator= | 将新内容分配给容器,替换其当前内容,并相应地修改其大小 |
begin | 返回指向容器中第一个元素的迭代器 |
end | 返回指向容器中最后一个元素之后的理论元素的迭代器 |
rbegin | 返回指向容器中最后一个元素的反向迭代器 |
rend | 返回一个反向迭代器,指向中第一个元素之前的理论元素 |
cbegin | 返回指向容器中第一个元素的常量迭代器(const_iterator) |
cend | 返回指向容器中最后一个元素之后的理论元素的常量迭代器(const_iterator) |
crbegin | 返回指向容器中最后一个元素的常量反向迭代器(const_reverse_iterator) |
crend | 返回指向容器中第一个元素之前的理论元素的常量反向迭代器(const_reverse_iterator) |
size | 返回容器中元素的数量 |
max_size | 返回容器可容纳的最大元素数 |
resize | 调整容器的大小,使其包含 n(参数)个元素 |
capacity | 返回当前为 vector 分配的存储空间(容量)的大小 |
empty | 返回 vector 是否为空 |
reserve | 请求 vector 容量至少足以包含 n(参数)个元素 |
shrink_to_fit | 要求容器减小其 capacity(容量)以适应其 size(元素数量) |
operator[] | 返回容器中第 n(参数)个位置的元素的引用 |
at | 返回容器中第 n(参数)个位置的元素的引用 |
front | 返回对容器中第一个元素的引用 |
back | 返回对容器中最后一个元素的引用 |
data | 返回指向容器中第一个元素的指针 |
assign | 将新内容分配给 vector,替换其当前内容,并相应地修改其 size |
push_back | 在容器的最后一个元素之后添加一个新元素 |
pop_back | 删除容器中的最后一个元素,有效地将容器 size 减少一个 |
insert | 通过在指定位置的元素之前插入新元素来扩展该容器,通过插入元素的数量有效地增加容器大小 |
erase | 从 vector 中删除单个元素(position)或一系列元素([first, last]),这有效地减少了被去除的元素的数量,从而破坏了容器的大小 |
swap | 通过 x(参数)的内容交换容器的内容,x 是另一个类型相同、size 可能不同的 vector 对象 |
clear | 从 vector 中删除所有的元素(被销毁),留下 size 为 0 的容器 |
emplace | 通过在 position(参数)位置处插入新元素 args(参数)来扩展容器 |
emplace_back | 在 vector 的末尾插入一个新的元素,紧跟在当前的最后一个元素之后 |
get_allocator | 返回与vector关联的构造器对象的副本 |
swap(vector) | 容器 x(参数)的内容与容器 y(参数)的内容交换。两个容器对象都必须是相同的类型(相同的模板参数),尽管大小可能不同 |
relational operators (vector) | 形如 vectorA > vectorB;依此比较每个元素的大小关系 |