Home 算法

STL

STL四大核心组件：容器(Containers)、算法(Algorithms)、迭代器(Iterators)和函数对象(Functors)

  • 容器：
    • 复制存储数据
    • 如动态数组、链表、哈希表等
  • 算法：
    • 负责操作数据
    • 如排序、查找、遍历等
  • 迭代器：
    • 容器和算法之间的桥梁
    • 让算法统一操作不同容器
  • 函数对象：
    • 用于自定义算法行为

顺序容器

顺序容器是STL中按元素顺序存储数据的容器，允许通过位置（如索引或迭代器）访问元素。它们不自动排序，元素的逻辑顺序与插入顺序一致。

vector

使用场景

  • 当你需要一个可以动态增长和缩小的数组时。
  • 当你需要频繁地在序列的末尾添加或移除元素时。
  • 当你需要一个可以高效随机访问元素的容器时。

要使用 vector，首先需要包含 <vector> 头文件：

1
#include <vector>

创建Vector

1
2
3
4
vector<int> myVector0; // 创建一个存储整数的空vector
vector<int> myVector1(5); // 创建一个包含 5 个整数的 vector，每个值都为默认值（0）
vector<int> myVector2(5, 10); // 创建一个包含 5 个整数的 vector，每个值都为 10
vector<int> myVector3 = {1, 2, 3, 4}; // 初始化一个包含元素的vector

添加元素

可以使用push_back方法向vector中添加元素

1
myVector.push_back(7); // 将整数 7 添加到 vector 的末尾

访问元素

可以使用下标操作符 [] 或 at() 方法访问 vector 中的元素：

1
2
int x = myVector[0]; // 获取第一个元素
int y = myVector.at(1); // 获取第二个元素

获取大小

可以使用 size() 方法获取 vector 中元素的数量：

1
int size = myVector.size(); // 获取 vector 中的元素数量

迭代访问

可以使用迭代器遍历 vector 中的元素：

1
2
3
for (auto it = myVector.begin(); it != myVector.end(); ++it) {
    std::cout << *it << " ";
}

或使用范围循环：

1
2
3
for (int element : myVector) {
    cout << element << " ";
}

删除元素

可以使用 erase() 方法删除 vector 中的元素：

1
myVector.erase(myVector.begin() + 2); // 删除第三个元素

清空元素

可以使用 clear() 方法清空 vector 中的所有元素：

1
myVector.clear(); // 清空 vector

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <iostream>
#include <vector>

int main() {
    // 创建一个空的整数向量
    std::vector<int> myVector;

    // 添加元素到向量中
    myVector.push_back(3);
    myVector.push_back(7);
    myVector.push_back(11);
    myVector.push_back(5);

    // 访问向量中的元素并输出
    std::cout << "Elements in the vector: ";
    for (int element : myVector) {
        std::cout << element << " ";
    }
    std::cout << std::endl;

    // 访问向量中的第一个元素并输出
    std::cout << "First element: " << myVector[0] << std::endl;

    // 访问向量中的第二个元素并输出
    std::cout << "Second element: " << myVector.at(1) << std::endl;

    // 获取向量的大小并输出
    std::cout << "Size of the vector: " << myVector.size() << std::endl;

    // 删除向量中的第三个元素
    myVector.erase(myVector.begin() + 2);

    // 输出删除元素后的向量
    std::cout << "Elements in the vector after erasing: ";
    for (int element : myVector) {
        std::cout << element << " ";
    }
    std::cout << std::endl;

    // 清空向量并输出
    myVector.clear();
    std::cout << "Size of the vector after clearing: " << myVector.size() << std::endl;

    return 0;
}

deque

  • deque双端队列是一种允许在两端进行插入和删除操作的线性数据结构。
  • deque全称是double-ended queue，它在C++中以模板类的形式存在，允许存储任意类型的数据。
  • 是一个动态数组，提供了快速的随机访问能力，同时允许在两端进行高效的插入和删除操作。
  • 要使用deque，需包含头文件
1
#include <deque>

创建deque

1
deque<int> myDeque;

插入元素

1
2
myDeque.push_back(10); // 从后端插入
myDeque.push_front(5); //从前端插入

访问元素

1
2
3
4
5
for (int i = 0; i < myDeque.size(); i++) {
    cout << myDeque[i] << " ";
} // 遍历数组
myDeque.front(); // 访问前端元素
myDeque.back(); // 访问后端元素

删除元素

1
2
myDeque.pop_back(); // 删除末端元素
myDeque.pop_front(); // 删除前端元素

实例1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <iostream>
#include <deque>

int main() {
    std::deque<int> myDeque;

    // 插入元素
    myDeque.push_back(10);
    myDeque.push_back(20);
    myDeque.push_front(5);

    // 访问元素
    std::cout << "Deque contains: ";
    for (int i = 0; i < myDeque.size(); ++i) {
        std::cout << myDeque[i] << " ";
    }
    std::cout << std::endl;

    // 删除元素
    myDeque.pop_back();
    myDeque.pop_front();

    // 再次访问元素
    std::cout << "Deque after popping: ";
    for (int i = 0; i < myDeque.size(); ++i) {
        std::cout << myDeque[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

实例2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <iostream>
#include <deque>

int main() {
    std::deque<int> d;

    // 向双端队列中添加元素
    d.push_back(10);
    d.push_back(20);
    d.push_front(5);

    // 访问前端元素
    std::cout << "Front element: " << d.front() << std::endl;

    // 访问后端元素
    std::cout << "Back element: " << d.back() << std::endl;

    // 修改前端元素
    d.front() = 15;

    // 修改后端元素
    d.back() = 25;

    // 再次访问元素
    std::cout << "Modified front element: " << d.front() << std::endl;
    std::cout << "Modified back element: " << d.back() << std::endl;

    return 0;
}

关联容器

map

查找类操作

成员函数 功能 示例
find(key) 查找键，返回迭代器 auto it = map.find("key");
count(key) 统计键的出现次数（0或1） if (map.count("key") > 0) { ... }
contains(key) C++20 新增，返回是否存在键 if (map.contains("key")) { ... }
lower_bound(key) 返回第一个不小于 key 的迭代器 auto it = map.lower_bound(42);
upper_bound(key) 返回第一个大于 key 的迭代器 auto it = map.upper_bound(42);
equal_range(key) 返回匹配键的范围迭代器对 auto [beg, end] = map.equal_range(42);

map.contains()需要C++20

插入/删除类操作

成员函数 功能 示例
insert(value) 插入元素（自动去重） map.insert({"key", 42});
emplace(args...) 原地构造元素 map.emplace("key", 42);
erase(key/iterator) 删除元素 map.erase("key");
merge(other) C++17 合并两个容器 map1.merge(map2);

set

Edited on