map，unordered_map，multimap，unordered

std::map（有序映射）
std::unordered_map（无序映射）
std::multimap（有序多重映射）
std::unordered_multimap（无序多重映射）

它们的使用方式和特点略有不同，下面分别介绍这些数据结构及其基本用法。

1. `std::map`（有序映射）

std::map 是一个有序的键值对容器，键（key）是唯一的，并且按顺序（通常是按升序）排列。

它底层是用红黑树实现的，因此查找、插入、删除的时间复杂度为 O(log n)。

特点：

有序性：键是有序的（按键的升序）。
唯一性：键是唯一的。
查找和插入的时间复杂度为 O(log n)。

下面是std::map` 的基本用法介绍：

引入头文件

使用 std::map 需要引入 <map> 头文件：

#include <map>

创建 `std::map`

std::map 的基本语法是：

std::map<KeyType, ValueType> mapName;

例如：

std::map<int, std::string> myMap;

这将创建一个以 int 类型为键、std::string 类型为值的映射。

插入元素

使用 [] 操作符插入元素：

myMap[1] = "One";

myMap[2] = "Two";

使用 insert 函数插入元素：

myMap.insert({3, "Three"});

myMap.insert(std::make_pair(4, "Four"));

访问元素

使用 [] 访问元素（如果键不存在，会插入一个默认值）：

std::string value = myMap[1];  // 获取键为 1 的值

使用 at 方法访问元素（如果键不存在，会抛出异常）：

std::string value = myMap.at(2);

查找元素

使用 find 方法查找键是否存在，返回一个迭代器。如果键不存在，则返回 map.end()：

auto it = myMap.find(2);

if (it != myMap.end()) {

    std::cout << "Key 2 found, value: " << it->second << std::endl;

} else {

    std::cout << "Key 2 not found" << std::endl;

}

遍历 `map`

可以使用范围 for 循环或迭代器遍历 map：

for (const auto& pair : myMap) {

    std::cout << pair.first << ": " << pair.second << std::endl;

}

或者使用迭代器：

for (auto it = myMap.begin(); it != myMap.end(); ++it) {

    std::cout << it->first << ": " << it->second << std::endl;

}

删除元素

使用 erase 删除指定键：

myMap.erase(2);  // 删除键为 2 的元素

使用迭代器删除：

auto it = myMap.find(3);

if (it != myMap.end()) {

    myMap.erase(it);  // 删除键为 3 的元素

}

获取 `map` 的大小和检查是否为空

使用 size 获取 map 的大小：

std::cout << "Map size: " << myMap.size() << std::endl;

使用 empty 检查是否为空：

if (myMap.empty()) {

    std::cout << "Map is empty" << std::endl;

}

示例代码

#include <iostream>

#include <map>

int main() {

    // 创建一个 map

    std::map<int, std::string> myMap;

    // 插入元素

    myMap[1] = "One";

    myMap[2] = "Two";

    myMap.insert({3, "Three"});

    myMap.insert(std::make_pair(4, "Four"));

    // 访问元素

    std::cout << "Key 1 has value: " << myMap[1] << std::endl;

    std::cout << "Key 2 has value: " << myMap.at(2) << std::endl;

    // 查找元素

    auto it = myMap.find(3);

    if (it != myMap.end()) {

        std::cout << "Found key 3 with value: " << it->second << std::endl;

    }

    // 遍历 map

    for (const auto& pair : myMap) {

        std::cout << pair.first << ": " << pair.second << std::endl;

    }

    // 删除元素

    myMap.erase(2);

    // 显示删除后的 map

    for (const auto& pair : myMap) {

        std::cout << pair.first << ": " << pair.second << std::endl;

    }

    return 0;

}

2. `std::unordered_map`（无序映射）

std::unordered_map 是一个无序的键值对容器，键是唯一的，但它没有按顺序存储。

它使用哈希表作为底层结构，查找、插入、删除的时间复杂度为 O(1)（均摊时间）。

特点：

无序性：键没有特定顺序。
唯一性：键是唯一的。
查找和插入的时间复杂度在均摊情况下为 O(1)（最坏情况 O(n)）。

3. `std::multimap`（有序多重映射）

std::multimap 是一个有序的键值对容器，允许多个相同的键。它类似于 std::map，但同一个键可以出现多次。

特点：

- 有序性：键是有序的。

非唯一性：允许键重复。
查找、插入的时间复杂度为 O(log n)。

4. `std::unordered_multimap`（无序多重映射）

std::unordered_multimap 是一个无序的键值对容器，也允许多个相同的键。它使用哈希表存储，但允许相同的键出现多次。

特点：

无序性：键没有顺序。
非唯一性：允许键重复。
查找和插入的时间复杂度在均摊情况下为 O(1)（最坏情况 O(n)）。

总结

std::map：有序且唯一键，底层实现为红黑树，查找和插入 O(log n)。
std::unordered_map：无序且唯一键，底层实现为哈希表，查找和插入 O(1)（均摊）。
std::multimap：有序且允许重复键，底层为红黑树，查找和插入 O(log n)。
std::unordered_multimap：无序且允许重复键，底层为哈希表，查找和插入 O(1)（均摊）。