STL使用.md · guoyingkui/G_w_G

#### vector（动态数组）
一个vector类似一个动态的一维数组。
vector中可以存在重复的元素。
底层基于连续的内存块，支持快速的随机访问，可通过索引直接访问元素。
##### 优缺点
```
优点：
1. 随机访问元素快
2. 节省空间
缺点：
1. 在头部插入、删除特别慢；在尾部插入、删除比较快；在内部插入、删除比较慢。
2. 当动态添加的数据超过默认分配的大小时，要进行整体的重新分配拷贝与释放。
3. 存储空间有限，必须是连续的空间
```
##### 适用场景
```
当需要频繁读取和修改元素，并且对插入和删除操作的性能要求不高时，可以选择vector。例如，在实现图像处理算法中，可以使用vector存储像素信息

①vector不适合push_front(效率很低)
②vector不适合中间插入删除操作。中间插入删除操作会引起内存拷贝。
```

##### 代码举例
```
#include <iostream>
#include <vector>

int main() {
    // 创建一个空的vector
    std::vector<int> vec;

// 向vector中添加元素
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(3);

// 遍历vector中的元素
    std::cout << "遍历vector中的元素：" << std::endl;
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

// 修改vector中的元素
    vec[0] = 4;

// 查找vector中的元素
    int numToFind = 3;
    auto it = std::find(vec.begin(), vec.end(), numToFind);
    if (it != vec.end()) {
        std::cout << "找到了元素 " << numToFind << " 在索引位置 " << std::distance(vec.begin(), it) << std::endl;
    } else {
        std::cout << "未找到元素 " << numToFind << std::endl;
    }

// 删除vector中的元素
    vec.erase(vec.begin() + 1);

// 再次遍历vector中的元素
    std::cout << "修改并删除后的vector中的元素：" << std::endl;
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

return 0;
}

```

#### map
提供一对一（其中第一个可以称为关键字，每个关键字只能在map中出现一次，第二个可能称为该关键字的值）的数据处理能力，
由于这个特性，它在我们处理一对一数据的时候，在编程上提供快速通道。
map内部自建一颗红黑树(一种非严格意义上的平衡二叉树)，这颗树具有对数据自动排序的功能。

比如一个班级中，每个学生的学号跟他的姓名就存在着一一映射的关系，这个模型用map可以轻易描述，很明显学号用int描述，姓名用字符串描述

##### 优缺点
```
优点：可以根据键值进行快速查找和插入操作，且键值唯一。
缺点：相对于其他容器，占用更多的内存空间。
```

##### 举例
```
#include <iostream>
#include <map>

int main() {
    // 创建一个map对象
    std::map<int, std::string> studentMap;

// 添加元素
    studentMap[1001] = "张三";
    studentMap[1002] = "李四";
    studentMap[1003] = "王五";

// 查找元素
    int studentID = 1002;
    if (studentMap.find(studentID) != studentMap.end()) {
        std::cout << "学生ID: " << studentID << " 姓名: " << studentMap[studentID] <<std::endl;
    } else {
        std::cout << "学生ID: " << studentID << " 未找到" << std::endl;
    }

// 更新元素
    studentID = 1003;
    if (studentMap.count(studentID) > 0) {
        studentMap[studentID] = "赵六";
        std::cout << "学生ID: " << studentID << " 姓名已更新为: " << studentMap[studentID] <<std::endl;
    } else {
        std::cout << "学生ID: " << studentID << " 未找到" << std::endl;
    }

// 删除元素
    studentID = 1001;
    if (studentMap.erase(studentID) > 0) {
        std::cout << "学生ID: " << studentID << " 已删除" << std::endl;
    } else {
        std::cout << "学生ID: " << studentID << " 未找到" << std::endl;
    }

// 遍历map
    std::cout << "当前学生信息：" << std::endl;
    for (const auto& pair : studentMap) {
        std::cout << "学生ID: " << pair.first << " 姓名: " << pair.second << std::endl;
    }

return 0;
}

```

#### list
list 封装了链表，是有序的。 不过在内存中不是连续的内存存储，不支持[]。每一个结点都包括一个信息块、一个前驱指针、一个后驱指针。可以不分配必须的内存大小就可以方便的进行添加和删除。
##### 优缺点
```
优点：
1. 不使用连续的内存进行存储，存储空间无限（只要内存够）。
2. 在内部插入、删除很快（不需要进行内存拷贝或者移动，只需要进行指针的更改）
缺点：
1. 随机查找太慢
2. 相比vector 占用内存比较大
```
##### 适用场景
```
①list适合插入删除频繁的场所。不管插入还是删除，时间基本上都是常数。
②list不适合随机线性访问
```

#### 举例
```
#include <iostream>
#include <list>

int main() {
    std::list<int> myList;

// 添加元素
    myList.push_back(10);
    myList.push_back(20);
    myList.push_back(30);

// 遍历输出
    std::cout << "List elements: ";
    for (auto it = myList.begin(); it != myList.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

// 查找元素
    int elementToFind = 20;
    auto findIt = std::find(myList.begin(), myList.end(), elementToFind);
    if (findIt != myList.end()) {
        std::cout << "Element " << elementToFind << " found at position: "
                  << std::distance(myList.begin(), findIt) << std::endl;
    } else {
        std::cout << "Element " << elementToFind << " not found" << std::endl;
    }

// 修改元素
    int elementToModify = 30;
    auto modifyIt = std::find(myList.begin(), myList.end(), elementToModify);
    if (modifyIt != myList.end()) {
        *modifyIt = 40;
        std::cout << "Element " << elementToModify << " modified to 40" << std::endl;
    }

// 删除元素
    int elementToDelete = 10;
    myList.remove(elementToDelete);
    std::cout << "Element " << elementToDelete << " deleted" << std::endl;

// 输出修改后的列表
    std::cout << "Modified List: ";
    for (auto it = myList.begin(); it != myList.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

return 0;
}

```

#### set
set 、map 属于标准关联容器，使用了非常高效的平衡检索二叉树：红黑树。 他们的插入、删除效率比其他序列容器高，因为不需要做内存拷贝或者移动，而是直接指向结点指针。内存中存储不连续。包含的key值不能包含相同的；占用空间比较大

##### 区别：
```
1. set 只有一个key值，map是一个键值对key+value
2. 效率都很高
```

##### 举例
```
#include <iostream>
#include <set>

int main() {
    std::set<int> mySet;

// 添加元素
    mySet.insert(10);
    mySet.insert(20);
    mySet.insert(30);

// 遍历并输出所有元素
    std::cout << "Set中的元素: ";
    for (const auto& element : mySet) {
        std::cout << element << " ";
    }
    std::cout << std::endl;

// 查找元素
    int target = 20;
    auto it = mySet.find(target);
    if (it != mySet.end()) {
        std::cout << target << " 存在于Set中" << std::endl;
    } else {
        std::cout << target << " 不存在于Set中" << std::endl;
    }

// 删除元素
    target = 30;
    int numErased = mySet.erase(target);
    if (numErased > 0) {
        std::cout << "成功删除 " << target << "，删除了 " << numErased << " 个元素" << std::endl;
    } else {
        std::cout << target << " 不存在于Set中，无法删除" << std::endl;
    }

// 修改元素（实际上Set中的元素不可修改，因为Set是基于键值的有序容器）

return 0;
}

```

guoyingkui/G_w_G

简介

发行版

贡献者

语言

近期动态

guoyingkui/G_w_G .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

语言

近期动态

搜索帮助

guoyingkui/G_w_G