全面解析C++ STL容器：高效编程的基础

本文链接：https://blog.youkuaiyun.com/m0_72877724/article/details/140422607

在本文中，我们将详细讲解C++标准库（STL）中的主要容器类型，探索它们的特点和适用场景。这不仅是C++编程面试中的常见话题，也是构建高效C++程序的基础。

1. 序列式容器（Sequence Containers）

序列式容器用于维护元素的有序集合，其中顺序是由元素的位置确定的。

1.1 `std::vector`

特点：

动态数组，支持快速随机访问。
元素在内存中连续存储。
在末尾添加和删除元素的效率较高（O(1) 均摊时间）。

适用场景：

需要频繁进行随机访问。
元素数量动态变化较大，且主要在末尾添加或删除。

代码示例：

#include <vector>
#include <iostream>
int main() {
    std::vector<int> vec = {1, 2, 3, 4};
    vec.push_back(5);
    std::cout << vec[0] << std::endl; // 输出1
    return 0;
}

1.2 `std::list`

特点：

双向链表，支持快速插入和删除操作。
不支持随机访问。

适用场景：

需要频繁进行插入和删除操作，但不需要随机访问。
内存分配和释放频繁的场景。

代码示例：

#include <list>
#include <iostream>
int main() {
    std::list<int> myList = {1, 2, 3, 4};
    myList.push_back(5);
    myList.push_front(0);
    for (auto el : myList) std::cout << el << " "; // 输出0 1 2 3 4 5 
    return 0;
}

1.3 `std::deque`

特点：

双端队列，在头部和尾部均支持高效的插入和删除操作。
内存块不连续，但支持快速随机访问。

适用场景：

需要在首尾两端进行插入和删除操作。
需要随机访问。

代码示例：

#include <deque>
#include <iostream>
int main() {
    std::deque<int> deq = {1, 2, 3, 4};
    deq.push_back(5);
    deq.push_front(0);
    std::cout << deq[1] << std::endl; // 输出1
    return 0;
}

2. 关联式容器（Associative Containers）

关联式容器用于维护元素的集合，每个元素都由键值对组成，基于键来快速查找元素。

2.1 `std::set`

特点：

存储唯一元素，自动排序。
基于平衡二叉树（通常是红黑树）实现，支持O(log n)的查找、插入和删除操作。

适用场景：

需要存储不重复的元素，并且需要自动排序。

代码示例：

#include <set>
#include <iostream>
int main() {
    std::set<int> mySet = {3, 1, 4, 1, 5};
    mySet.insert(2);
    for (auto el : mySet) std::cout << el << " "; // 输出1 2 3 4 5 
    return 0;
}

2.2 `std::map`

特点：

存储键值对，键唯一且自动排序。
基于平衡二叉树（通常是红黑树）实现，支持O(log n)的查找、插入和删除操作。

适用场景：

需要根据键进行排序和查找。

代码示例：

#include <map>
#include <iostream>
int main() {
    std::map<std::string, int> myMap = {{"apple", 1}, {"banana", 2}};
    myMap["cherry"] = 3;
    for (const auto& [key, value] : myMap) std::cout << key << ": " << value << std::endl;
    return 0;
}

3. 无序关联式容器（Unordered Associative Containers）

无序关联式容器基于哈希表实现，不保证元素顺序，但在大多数情况下提供了更好的平均性能。

3.1 `std::unordered_set`

特点：

存储唯一元素，无序。
基于哈希表实现，支持O(1)的平均时间复杂度查找、插入和删除操作。

适用场景：

需要存储不重复的元素，但不需要排序。

代码示例：

#include <unordered_set>
#include <iostream>
int main() {
    std::unordered_set<int> mySet = {3, 1, 4, 1, 5};
    mySet.insert(2);
    for (auto el : mySet) std::cout << el << " "; // 输出可能是1 2 3 4 5 的任意顺序
    return 0;
}

3.2 `std::unordered_map`

特点：

存储键值对，键唯一且无序。
基于哈希表实现，支持O(1)的平均时间复杂度查找、插入和删除操作。

适用场景：

需要基于键进行快速查找和插入，但不需要排序。

代码示例：

#include <unordered_map>
#include <iostream>
int main() {
    std::unordered_map<std::string, int> myMap = {{"apple", 1}, {"banana", 2}};
    myMap["cherry"] = 3;
    for (const auto& [key, value] : myMap) std::cout << key << ": " << value << std::endl;
    return 0;
}

4. 容器适配器（Container Adaptors）

容器适配器是基于现有容器实现的一类容器，通过限制功能来提供更简洁的接口。

4.1 `std::stack`

特点：

后进先出（LIFO）。
基于 deque、vector 或 list 实现。

适用场景：

需要只在一端进行插入和删除操作的场景。

代码示例：

#include <stack>
#include <iostream>
int main() {
    std::stack<int> s;
    s.push(1);
    s.push(2);
    std::cout << s.top() << std::endl; // 输出2
    s.pop();
    std::cout << s.top() << std::endl; // 输出1
    return 0;
}

4.2 `std::queue`

特点：

先入先出（FIFO）。
基于 deque 或 list 实现。

适用场景：

需要只在两端进行插入和删除操作的场景。

代码示例：

#include <queue>
#include <iostream>
int main() {
    std::queue<int> q;
    q.push(1);
    q.push(2);
    std::cout << q.front() << std::endl; // 输出1
    q.pop();
    std::cout << q.front() << std::endl; // 输出2
    return 0;
}

4.3 `std::priority_queue`

特点：

元素按照优先级排序，最大元素优先。
基于 vector 或 deque 实现。

适用场景：

需要快速访问最大（或最小）元素的场景。

代码示例：

#include <queue>
#include <vector>
#include <iostream>
int main() {
    std::priority_queue<int> pq;
    pq.push(1);
    pq.push(3);
    pq.push(2);
    std::cout << pq.top() << std::endl; // 输出3
    pq.pop();
    std::cout << pq.top() << std::endl; // 输出2
    return 0;
}