片头
嗨！小伙伴们，大家好~ 今天，我们来一起学习C++的vector类，准备好了吗？咱们开始咯！
一、vector的介绍及使用
1.1 vector的介绍
（1）vector是表示可变大小数组的序列容器。
（2）就像数组，vector也采用连续存储空间来存储元素。这也说明，可以采用下标对vector的元素进行访问，和数组一样高效，但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
（3）本质上，vector使用动态分配数组来存储它的元素。当新元素插入时，为了增加存储空间，这个数组需要被重新分配大小。做法：分配一个新的数组，然后将全部元素移动到这个数组。在时间上，这是一个相对代价高的任务。因为每当一个新的元素加入到容器时，vector并不会每次都重新分配大小。
（4）vector分配空间策略：vector会分配一些额外的空间以适应可能得增长，因为存储空间比实际需要的存储空间更大，不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
（5）因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
（6）与其他动态序列的容器相比（deque,list and forward_list），vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效，对于其他不在末尾的删除和插入操作，效率更低。比起list和forward_list统一的迭代器和引用更好
1.2 vector的常用接口
1.2.1 常用的构造函数
| （constructor）构造函数声明 | 接口说明 |
| vector()（重点） | 无参构造 |
| vector(size_type n,const value_type& val = value_type()); | 构造并初始化n个val |
| vector(const vector& x);（重点） | 拷贝构造 |
| vector(InputIterator first,InputIterator last); | 使用迭代器进行初始化构造 |
下面我们一一介绍
（1）vector();
vector类的默认构造函数，构造一个没有元素的空容器
例如：
（2）vector(size_type n,const value_type& val = value_type());
构造一个vector类对象并用n个val初始化
例如：
（3）vector(const vector& x);
vector类的拷贝构造函数
例如：
（4）Template<class InputIterator>
vector(InputIterator first,InputIterator last);
使用迭代器进行初始化构造
例如：
1.2.2 vector iterator 的使用
| iterator的使用 | 接口说明 |
| begin + end （重点） | 获取第一个位置的iterator/const_iterator，获取最后一个数据的下一个位置的iterator/const_iterator |
| rbegin + rend | 获取最后一个数据位置的reverse_iterator，获取第一个数据前一个位置的reverse_iterator |
1.2.3 容量操作接口
| 容量空间 | 接口说明 |
| size | 获取数据个数 |
| capacity | 获取容量大小 |
| empty | 判断是否为空 |
| resize（重点） | 改变vector的size |
| reserve（重点） | 改变vector的capacity |
- capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。但不要固化的认为，vector增容都是2倍，具体增长多少是根据具体的需求定义的。vs是PJ版本的STL，g++是SGI版本STL。
- reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问题。
- resize在开空间的同时还会进行初始化，影响size
（1）size
size_type size() const;
获取有效元素个数
例如：
（2）capacity
size_type capacity() const;
获取容量大小
例如：
（3） empty
bool empty() const;
判断容器是否为空
例如：
（4）resize
void resize(size_type n,value_type val = value_type());
将有效元素的个数修改为n，并且如果n大于原来的size，多出来的地方用val填充
如果没有给出val，就用0填充
例如：
（5） reserve
void reserve(size_type n);
改变容量大小
例如：
1.2.4 访问和遍历
| 访问和遍历接口 | 接口说明 |
| operator[]（重点） | 像数组一样访问 |
| 迭代器（正向、反向迭代器） | 用迭代器去遍历访问 |
| at(size_type n); | 返回容器中位置n处的元素的引用 |
| back() | 返回容器中最后一个元素的引用 |
| front() | 返回容器中第一个元素的引用 |
（1）operator[]
reference operator[](size_type n);
const_reference operator[](size_type n) const;
用下标访问vector
例如：
（2）迭代器
iterator begin();
const_iterator begin() const;
iterator end();
const_iterator end() const;
迭代器，用于获取容器中第一个元素的位置和最后一个元素的下一个位置
例如：
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
reverse_iterator rend();
const_reverse_iterator rend() const;
反向迭代器，rbegin获取容器中的最后一个元素的位置，rend获取容器中的第一个元素的前一个位置
例如：
使用反向迭代器时，rit仍然是++,而不是--
（3）at
reference at(size_type n);
const_reference at(size_type n)const;
返回容器中位置n处的元素的引用
例如：
（4）back
reference back();
const_reference back() const;
返回容器中最后一个元素的引用
例如：
（5）front
reference front();
const_reference front() const;
返回容器中第一个元素的引用
例如：
1.2.5 vector的增删查改
| vector的增删查改相关接口 | 说明 |
| push_back（重点） | 从容器尾部插入一个元素 |
| pop_back（重点） | 从容器尾部删除一个元素 |
| find | 在2个迭代器区间寻找val并返回其所在处的迭代器 |
| insert | 在pos位置插入元素 |
| erase | 删除pos位置的元素或者 [first，last)区间的所有元素 |
| swap | 交换2个vector的数据空间 |
| assign | 为vector指定新内容，替换其当前内容并修改size |
| clear | 从vector中删除所有元素，不改变容量大小 |
（1）push_back
void push_back(const value_type& val);
从容器尾部插入一个元素
例如：
（2）pop_back
void pop_back();
从容器尾部删除一个元素
例如：
（3）find
template<class InputIterator,class T>
InputIterator find(InputIterator first,InputIterator last,const T& val);
在两个迭代器区间寻找val并返回其所在处的迭代器
注意：vector库中是没有find函数的，我们这里使用的是算法库里面的find，是包含在头文件<algorithm>中的
这个函数的参数包括：
- first 和 last 是输入迭代器（InputIterator），它们一起定义了一个序列的范围（即 [first，last)）。这个范围包括指向 first 元素的位置直到 last 位置但不包括 last 本身。find 函数在这个范围内查找 val 。
- val 是要找的值。这个值需要跟序列中元素类型兼容。find 函数会使用元素类型的 operator== 来比较每个元素是否跟 val 相等
find 函数的行为是线性搜索；它从 first 索引开始，逐个比较每个元素直到 last 索引之前，查找一个等于 val 的元素。
返回值：
- 如果找到，find 函数返回一个迭代器，指向第一个等于 val 的元素
- 如果在 [first，last) 范围内没有找到 val，则返回 last，表示查找失败
例如：
需要注意的是，该函数并非vector的成员函数，是标准库中的函数，多个容器共用该find函数
（4）insert
iterator insert(iterator position,const value_type& val);
void insert(iterator position,size_type n,const value_type& val);
在position位置插入元素
例如：
对于这类可能会修改容量的函数，容易导致迭代器失效的问题，后面再细讲
所以，insert函数不仅需要完成插入元素的工作，有时还需要返回新的迭代器
（5）erase
iterator erase(iterator position);
iterator erase(iterator first,iterator last);
删除position位置的元素或者 [first，last)区间的所有元素
例如：
（6）swap
void swap(vector& x);
交换2个vector的数据空间
例如：
（7）assign
template<class InputIterator>
void assign(InputIterator first,InputIterator last);
void assign(size_type n,const value_type& val);
为vector指定新内容，替换其当前内容并修改size
例如：
（8）clear
void clear();
从vector中删除所有元素，不改变容量的大小
例如：
1.3 迭代器失效
迭代器的底层实际上就是一个指针或指针的封装，比如：vector的迭代器就是原生态指针T*。
当迭代器底层的指针指向的空间被销毁时，如果继续在程序中使用该迭代器，就会造成程序崩溃，这就是迭代器失效。
对于vector，可能会导致其迭代器失效的操作有：
- 可能造成空间改变的操作，比如：resize、reserve、insert、assign、push_back等。
void Test24() {
vector<int> v1{ 1,2,3,4,5 };
auto it = v1.begin();
//将有效元素的个数增加到100个,多出的位置使用6填充,操作期间底层会扩容
v1.resize(100, 6);
//reserve的作用就是改变扩容大小但不改变有效元素个数,操作期间可能会引起底层容量的改变
v1.reserve(100);
//插入元素期间,可能会引起扩容,而导致原空间被释放
v1.insert(v1.begin(), 0);
v1.push_back(6);
//给vector重新赋值,可能会引起底层容量改变
v1.assign(100, 6);
while (it != v1.end()) {
cout << *it << " ";
++it;
}
cout << endl;
}为什么会出错呢？因为，以上操作，都有可能会导致vector扩容，也就是说，vector底层旧空间被释放掉，而在打印时，it还使用的是释放之前的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的空间，从而引起代码运行时崩溃。
解决方法：在以上操作完成后，如果想继续通过迭代器操作vector中的元素，只需给it重新赋值即可。
- 指定位置元素的删除操作---erase
void Test25() {
int a[5] = { 1,2,3,4,5 };
vector<int> v(a, a + sizeof(a) / sizeof(int));
//使用find查找"3"所在位置的iterator
vector<int>::iterator pos = find(v.begin(), v.end(), 3);
//删除pos位置的数据
v.erase(pos);
cout << *pos << endl;//此处会导致非法访问
}erase删除pos位置元素后，pos位置之后的元素会往前搬移，该迭代器对应的元素发生改变，属于迭代器失效。
如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是没有元素的，迭代器pos就超出了有效元素范围，可能导致非法访问，那么pos就失效了。因此，删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。
比如：删除vector中所有的偶数，代码如下：
void Test26() {
int a[5] = { 1,2,3,4,5 };
vector<int> v(a, a + 5);
vector<int>::iterator it1 = v.begin();
while (it1 != v.end()) {
if (*it1 % 2 == 0) {
//遇到偶数,就把它删除,it1指向下一个位置的元素
it1 = v.erase(it1);
}
else {
//若为奇数,it1指向下一个位置
++it1;
}
}
}迭代器失效后，如果我们需要继续使用迭代器，给迭代器重新赋值即可。
1.4 小练习
题目告诉我们，只有1个元素只出现1次，其余的元素均出现2次。
我们可以采用异或的思想来解决，
①2个相同的数字做异或运算，结果为0。这个结果可以帮我们排除掉成对的数字。
②0和任何数字做异或运算，都得到这个数字本身。
所以，只要对nums中所有的元素进行异或，就可以得到答案
代码如下：
class Solution {
public:
int singleNumber(vector<int>& nums) {
int ret = 0;
for(auto e : nums){
ret ^= e;
}
return ret;
}
};
这道题，给出了vector的模板，让我们返回vector<vector<int>>类型的结果
思路：我们可以利用vector类模板，把它想象成二维数组，实例化后，生成2个类。一个类是vector<int>，template<class int>，里面的成员变量时int* _a，指向int类型的数组；
再用vector<int>作为参数，传递给template<class T>，得到template<class vector<int>>，里面的成员变量是vector<int>* _a，也就是vector<vector<int>>，指向int*类型的数组。
本道题的代码如下：
方法一：
class Solution {
public:
vector<vector<int>> generate(int numRows) {
vector<vector<int>> vv; //创建一个类似的二维数组
vv.resize(numRows); //创建numRows行
for(int i = 0; i<numRows ; i++){
vv[i].resize(i+1,0); //每一行创建i+1个空间存放元素,并初始化全部为0
}
//遍历二维数组
for(int i = 0; i< vv.size();i++){
for(int j = 0; j< vv[i].size();j++){
if(j == 0 || j == vv[i].size()-1){
//第1列和最后1列的元素都是1
vv[i][j] = 1;
}else{
//中间的元素等于上一列的相邻两个元素相加
vv[i][j] = vv[i-1][j-1] + vv[i-1][j];
}
}
}
//将结果返回
return vv;
}
};方法二：
class Solution {
public:
vector<vector<int>> generate(int numRows) {
vector<vector<int>> vv;
vv.resize(numRows); //创建numRows行
for(size_t i = 0; i < numRows; i++) {
vv[i].resize(i+1,0); //每一行创建i+1个空间存放元素,并初始化全部为0
//将每一行的第1个和每一行的最后1个初始化为1
vv[i][0] = vv[i][vv[i].size()-1] = 1;
}
//遍历二维数组
for(size_t i = 0; i < vv.size(); i++){
for(size_t j = 0; j < vv[i].size(); j++){
if(vv[i][j] == 0) {
//中间的元素等于上一列的相邻两个元素相加
vv[i][j] = vv[i-1][j] + vv[i-1][j-1];
}
}
}
//将结果返回
return vv;
}
};方法一和方法二大同小异，大家可以自由选择
举个例子呗~
题目的意思是，我们必须在原有的数组进行去重，不能开辟另一个新数组。最后返回数组的长度。
思路：（双指针法：i 为快指针，用来扫描；k 为慢指针，指向答案位置
当 nums[i] != nums[k] ，找到不重复项，复制到答案位置，k 指针前进一步）
我们可以先遍历整个数组，i 从下标为1的位置开始，到size位置结束。
定义变量 k ，初始值为1，表示数组中唯一元素的数量
(因为即便是整个数组中只有1个数字,所有数字都是重复的,那么数组中至少有1个数字)
如果遍历数组时,发现后一个数 != 前一个数，那么k++，nums[k] = nums[i]；
最后返回 k
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
if(nums.size() == 0) return 0; //如果nums数组为空,直接返回0
int k = 1; //慢指针,指向答案位置
//快指针,用于扫描
for(int i = 1; i < nums.size(); i++)
{
if(nums[i] != nums[k-1]) //若后一个 != 前一个
{
nums[k++] = nums[i]; //复制到答案位置,k自增
}
}
return k; //返回唯一元素的个数
}
};当然啦，我们还可以通过 i 来自己比较前一个元素和后一个元素是否相等，优化后的代码如下：
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
if(nums.size() == 0) return 0; //如果nums数组为空,直接返回0
int k = 1; //数组中唯一元素的数量,
//初始值也表示指向下标为1的位置
for(int i = 1; i < nums.size(); i++)
{
if(nums[i] != nums[i-1]) //如果后一个 != 前一个
{
nums[k++] = nums[i]; //当前i对应的值赋给nums[k],k自增
}
}
return k; //返回k
}
};1.5 vector和sort函数
注意，使用sort函数时，需要引用头文件#include<algorithm>
我们测试一下：
那如果我只想中间的数参与排序，第一个元素和最后一个元素不参与呢？
又或者是我只想让前一半的数参与排序呢？
可以看到，前面这3个例子，我们都排成的是升序，每个数之间用“<”来连接。
如果我们想排成降序呢？
那必须用到仿函数，仿函数可以帮助我们将数据排成降序。
例如：
此外，greater<int>可以支持2个数进行比较
事实上，我们还可以传递匿名对象
片尾
今天，我们学习了vector类的使用和2道练习题，希望看完这篇文章对友友们有所帮助！！！
求点赞收藏加关注！！！
谢谢大家！！！
扫一扫
7597
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
