vector 向量容器入门_vector容器怎么学习-优快云博客

本文链接：https://blog.youkuaiyun.com/JoshuaTsui/article/details/105544791

欢迎前往我的个人博客阅读原文。

在刷 LeetCode 的过程中，如果使用 c++ 进行提交，基本上都会遇到 vector 向量容器。由于以前学习 c++ 的过程中，没有涉及到容器的相关概念，一直都对 vector 一头雾水，所以我决定深入学习一些 c++ 的知识，今天就从 vector 向量容器开始。

vector 向量容器不但能像数组一样对元素进行随机访问，还能在尾部插入元素，是一种简单、高效的容器，完全可以替代数组。而且，vector 具有内存自动管理的功能，对于元素的插入和删除，可动态调整所占的内存空间。

使用 vector 向量容器，需要头文件包含声明

#include<vector>

创建 vector 对象

创建 vector 对象常用的有三种形式：

不指定容器的元素个数，如
```
vector<int> v;
```
创建时，指定容器的大小，如：
```
vector<double> v(10);
```
创建一个具有 $n$ 个元素的向量容器对象，每个元素具有指定的初始值，如：
```
vector<double> v(10, 8.6);
```
上述语句定义了 v 向量容器，共有 10 个元素，每个元素的值是 8.6。

尾部元素扩张

通常使用 push_back() 对 vector 容器在尾部追加新元素，既可对空的 vector 容器对象扩张，也可对有元素的 vector 容器对象扩张，vector 容器会自动分配新的内存空间。

#include<vector>
using namespace std;
int main(int argc, char* argv[])
{
    vector<int> v;
    v.push_back(4);
    v.push_back(7);
    v.push_back(6);
    return 0;
}

上述例子中，将 4，7，6 三个元素从尾部添加到 v 容器中，这样，v 容器中就有三个元素，依次是 4，7，6。

下标方式访问 vector 元素

对于 vector 对象，类似于数组的访问，可以采用下标方式随意访问它的某个元素，也可以以下标方式对某元素重新赋值。

#include<vector>
#include<iostream>
using namespace std;
int main(int argc, char* argv[])
{
    vector<int> v(3);
    v[0] = 4;
    v[1] = 7;
    v[2] = 6;
    cout << v[0] << ' ' << v[1] << ' ' << v[2] << endl;
    return 0;
}

上面的代码采用下标方式进行赋值，再输出元素的值 4，7，6。

使用迭代器访问 vector 元素

使用迭代器配合循环语句对 vector 对象进行遍历访问，迭代器的类型一定要与它要遍历的 vector 对象的元素类型一致。(虽说我还不知道迭代器是啥，先学吧，以后再补充)。

#include<vector>
#include<iostream>
using namespace std;
int main(int argc, char* argv[])
{
    vector<int> v(3);
    v[0] = 4;
    v[1] = 7;
    v[2] = 6;
    // 定义迭代器变量
    vector<int>::iterator it;
    for (it = v.begin(); it != v.end(); it++)
    {
        // 输出迭代器上的元素值
        cout << *it << ' ';
    }
    cout << endl;
    return 0;
}

上面的代码采用迭代器对 vector 进行了遍历，输出 4，7，6。

元素的插入

insert() 方法可以在 vector 对象的任意位置前插入一个新的元素，同时，vector 自动扩张一个元素空间，插入位置后的所有元素依次向后挪动一个位置。

注意：insert() 方法要求插入的位置，是元素的迭代器位置，而不是元素的下标。

#include<vector>
#include<iostream>
using namespace std;
int main(int argc, char* argv[])
{
    vector<int> v(3);
    v[0] = 4;
    v[1] = 6;
    v[2] = 7;
    // 在最前面插入新元素，元素值为 8
    v.insert(v.begin(), 8);
    // 在第 2 个元素前插入新元素 1
    v.insert(v.begin() + 2, 1);
    // 在向量末尾追加新元素 3
    v.insert(v.end(), 3);
    // 定义迭代器变量
    vector<int>::iterator it;
    for (it = v.begin(); it != v.end(); it++)
    {
        // 输出迭代器上的元素值
        cout << *it << ' ';
    }
    cout << endl;
    return 0;
}

上面的代码输出的结果是 8，4，1，6，7，3。

vector 容器有两个重要的方法，begin() 和 end() 。begin() 返回的是首元素位置的迭代器；end() 返回的是最后一个元素的下一个元素位置的迭代器。

元素的删除

erase() 方法可以删除 vector 中迭代器所指的一个元素或一段区间中的所有元素。
clear() 方法则一次性删除 vector 中的所有元素。

下面的代码演示了 vector 元素的删除方法：

#include<vector>
#include<iostream>
using namespace std;
int main(int argc, char* argv[])
{
    vector<int> v(10);
    // 给向量赋值
    for (int i = 0; i < 10; i++)
        v[i] = i;
    // 删除第 2 个元素，从 0 开始计数
    v.erase(v.begin() + 2);
    // 定义迭代器变量
    vector<int>::iterator it;
    for (it = v.begin(); it != v.end(); it++)
    {
        // 输出迭代器上的元素值
        cout << *it << ' ';
    }
    cout << endl;
    // 删除迭代器第 1 到第 5 区间的所有元素
    v.erase(v.begin() + 1, v.begin() + 5);
    for (it = v.begin(); it != v.end(); it++)
        cout << *it << ' ';
    cout << endl;
    // 清空向量
    v.clear();
    // 输出向量大小
    cout << v.size() << endl;
    return 0;
}

运行结果：

0 1 3 4 5 6 7 8 9
0 6 7 8 9
0

向量的大小

使用 size() 方法可以返回向量的大小，即元素的个数。
使用 empty() 方法返回向量是否为空。

下面这段代码演示了 size() 方法和 empty() 的用法：

#include<vector>
#include<iostream>
using namespace std;
int main(int argc, char* argv[])
{
    vector<int> v(10);
    // 给向量赋值
    for (int i = 0; i < 10; i++)
        v[i] = i;
    // 输出向量的大小，即包含了多少个元素
    cout << v.size() << endl;
    // 输出向量是否为空，如果非空，则返回逻辑假，即 0，否则返回逻辑真，即 1
    cout << v.empty() << endl;
    // 清空向量
    v.clear();
    cout << v.empty() << endl;
    return 0;
}

运行结果：

10
0
1

与反向、排序算法的结合

首先需要声明以下头文件：

#include<algorithm>

使用 reverse 反向排列算法

reverse 算法可以将向量中某段迭代器区间元素反向排列，如

#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;
int main(int argc, char* argv[])
{
    vector<int> v(10);
    // 给向量赋值
    for (int i = 0; i < 10; i++)
        v[i] = i;
    // 反向排列向量的从首到尾间的元素
    reverse(v.begin(), v.end());
    // 定义迭代器变量
    vector<int>::iterator it;
    for (it = v.begin(), it != v.end(); it++)
    {
        // 输出迭代器上的元素值
        cout << *it << ' ';
    }
    cout << endl;
    return 0;
}

使用 sort 算法对向量元素排序

sort 算法要求使用随机访问迭代器进行排序，在默认情况下，对向量元素进行升序排列。

#include<vector>
#include<iostream>
using namespace std;
int main(int argc, char* argv[])
{
    vector<int> v;
    int i;
    // 赋值
    for (i = 0; i < 10; i++)
        v.push_back(9 - i);
    // 输出排序前的元素值
    for (i = 0; i < 10; i++)
        cout << v[i] << ' ';
    cout << endl;
    // 排序，升序排列
    sort(v.begin(), v.end());
    // 输出排序后的元素值
    for (i = 0; i < 10; i++)
        cout << v[i] << ' ';
    cout << endl;
    return 0;
}

还可以自己设计排序比较函数，然后，把这个函数指定给 sort 算法，那么，sort 就根据这个比较函数指定的排序规则进行排序。下面的程序子集设计了一个排序比较函数 Comp，要求对元素的值由大到小排序：

#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;
// 自己设计排序比较函数：对元素的值进行降序排列
bool Comp(const int &a, const int &b)
{
    if (a != b)
        return a > b;
    else
        return a > b;
}
int main(int argc, char* argv[])
{
    vector<int> v;
    int i;
    // 赋值
    for (i = 0; i < 10; i++)
        v.push_back(i);
    // 输出排序前的元素值
    for (i = 0; i < 10; i++)
        cout << v[i] << ' ';
    cout << endl;
    // 按 Comp 函数比较规则排序
    sort(v.begin(), v.end(), Comp);
    // 输出排序后的元素值
    for (i = 0; i < 10; i++)
        cout << v[i] << ' ';
    cout << endl;
    return 0;
}