C++:多种map的定义及用法

1. std::map

• 实现：std::map 使用自平衡的二叉搜索树（通常是红黑树）来存储元素。
• 特点：
  • 有序：元素按照键的顺序自动排序。
  • 键唯一性：每个键在 std::map 中是唯一的。
  • 复杂度：插入、删除和查找操作的时间复杂度为对数时间（O(log N)）。
  • 默认哈希函数：std::map 使用键的 < 运算符进行比较。

示例代码：

#include <iostream>
#include <map>
#include <string>

int main() {
    // 创建一个 std::map 对象，键为 std::string，值为 int
    std::map<std::string, int> mmap;

    // 插入键值对
    mmap["apple"] = 3;
    mmap["banana"] = 2;
    mmap["cherry"] = 5;

    // 查找键 "banana" 并打印对应的值
    auto search = mmap.find("banana");
    if (search != mmap.end()) {
        std::cout << "Found banana with value: " << search->second << std::endl;
    } else {
        std::cout << "Banana not found!" << std::endl;
    }

    // 遍历 std::map 并打印所有键值对
    for (const auto& pair : mmap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // 删除键 "apple"
    mmap.erase("apple");

    return 0;
}

2. std::multimap

• 实现：std::multimap 与 std::map 类似，但允许键重复。它同样使用自平衡的二叉搜索树（通常是红黑树）来存储元素。
• 特点：
  • 有序：元素按照键的顺序自动排序。
  • 键允许重复：一个键可以有多个值。
  • 复杂度：插入、删除和查找操作的时间复杂度为对数时间（O(log N)）。

示例代码：

#include <iostream>
#include <map>
#include <string>

int main() {
    // 创建一个 std::multimap 对象，键为 std::string，值为 int
    std::multimap<std::string, int> mmap;

    // 插入键值对
    mmap.insert({"apple", 3});
    mmap.insert({"banana", 2});
    mmap.insert({"apple", 4});  // 允许重复的键

    // 查找键 "apple" 并打印对应的所有值
    auto range = mmap.equal_range("apple");
    for (auto it = range.first; it != range.second; ++it) {
        std::cout << "Apple value: " << it->second << std::endl;
    }

    // 遍历 std::multimap 并打印所有键值对
    for (const auto& pair : mmap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // 删除键 "apple"
    mmap.erase("apple");

    return 0;
}

3. std::unordered_map

• 哈希表实现：

  • unordered_map 使用哈希表来实现数据存储。哈希表通过哈希函数将键映射到哈希表的桶中，从而实现常数时间复杂度的平均插入、删除和查找操作。

• 无序存储：

  • 与 std::map 不同，unordered_map 不会按照键的顺序来存储元素，而是根据哈希值来组织桶。因此，它的元素顺序是不确定的。

• 键唯一性：

  • 每个键在 unordered_map 中是唯一的。如果插入一个已有键的键值对，旧的值会被新值替换。

• 自定义哈希函数和比较函数：

  • unordered_map 允许用户定义自己的哈希函数和键比较函数，以便用于特定类型的键。默认情况下，它使用 std::hash 作为哈希函数，使用 std::equal_to 作为比较函数。

示例代码：

#include <iostream>
#include <unordered_map>
#include <string>

int main() {
    // 创建一个 unordered_map 对象，键为 std::string，值为 int
    std::unordered_map<std::string, int> umap;

    // 插入键值对
    umap["apple"] = 3;
    umap["banana"] = 2;
    umap["cherry"] = 5;

    // 查找键 "banana" 并打印对应的值
    auto search = umap.find("banana");
    if (search != umap.end()) {
        std::cout << "Found banana with value: " << search->second << std::endl;
    } else {
        std::cout << "Banana not found!" << std::endl;
    }

    // 遍历 unordered_map 并打印所有键值对
    for (const auto& pair : umap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // 删除键 "apple"
    umap.erase("apple");

    return 0;
}

4. std::unordered_multimap

• 实现：std::unordered_multimap 使用哈希表来存储元素，允许键重复。
• 特点：
  • 无序：元素的顺序是不可预测的。
  • 键允许重复：一个键可以有多个值。
  • 复杂度：在理想情况下，插入、删除和查找操作的时间复杂度为常数时间（O(1)），但在最坏情况下可能退化为线性时间（O(N)）。
  • 哈希函数：std::unordered_multimap 使用哈希函数来确定键的存储位置，默认使用 std::hash，但可以自定义哈希函数。

示例代码：

#include <iostream>
#include <unordered_map>
#include <string>

int main() {
    // 创建一个 std::unordered_multimap 对象，键为 std::string，值为 int
    std::unordered_multimap<std::string, int> ummap;

    // 插入键值对
    ummap.insert({"apple", 3});
    ummap.insert({"banana", 2});
    ummap.insert({"apple", 4});  // 允许重复的键

    // 查找键 "apple" 并打印对应的所有值
    auto range = ummap.equal_range("apple");
    for (auto it = range.first; it != range.second; ++it) {
        std::cout << "Apple value: " << it->second << std::endl;
    }

    // 遍历 std::unordered_multimap 并打印所有键值对
    for (const auto& pair : ummap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // 删除键 "apple"
    ummap.erase("apple");

    return 0;
}

总结

• std::map：有序的键值对容器，基于红黑树实现。
• std::multimap：有序的键值对容器，允许键重复，基于红黑树实现。
• std::unordered_map：无序的键值对容器，基于哈希表实现。
• std::unordered_multimap：无序的键值对容器，允许键重复，基于哈希表实现。

每种 map 类型都有其特定的用途和优缺点，可以根据具体的需求和性能要求来选择合适的容器。