C++ 无序多重映射

C++ unordered multimaps 是 STL multimaps，其中元素不以任何排序顺序存储。

Unordered multimap 中的元素不是根据其键或值排序的。相反，它们使用 hash 值组织成 buckets，以便通过键进行快速直接访问，从而实现恒定的平均时间复杂度。

键和值的 数据类型可能不同。

创建无序多重映射

为了在 C++ 中创建无序多重映射，我们首先需要包含 <unordered_map> 头文件。

#include <unordered_map>  

初始化无序多重映射的语法是

std::unordered_multimap<int, std::string> my_unordered_multimap;

这将创建一个名为 my_unordered_multimap 的无序多重映射，用于存储 键值 对，其中键类型为 int，值类型为 std::string。

unordered_multimap<int, string> my_unordered_multimap;

示例：C++ 无序多重映射

#include <iostream>
#include <unordered_map>
  
using namespace std;

int main() {

    // create an unordered_multimap
    // with integer keys and string values
    unordered_multimap<int, string> my_unordered_multimap {
        {1, "Apple"},
        {22, "Banana"},
        {1, "Apricot"},
        {3, "Avocado"}
    };

    // print the elements
    cout << "Unordered Multimap Elements:" << endl;
    for (const auto& pair : my_unordered_multimap) {
        cout << pair.first << ": " << pair.second << endl;
    }

    return 0;
}

输出

Unordered Multimap Elements:
3: Avocado
22: Banana
1: Apricot
1: Apple

在这里，我们创建了一个名为 my_unordered_multimap 的无序多重映射，它有两个共享相同键 1 的元素。

如您所见，元素不是按排序顺序存储的。

请注意以下代码，

for (const auto& pair : my_unordered_multimap) {
    cout << pair.first << ": " << pair.second << endl;
}

在这里，循环变量 pair 存储 my_unordered_multimap 中存在的 键值 对。然后我们可以使用 pair.first 访问 键，使用 pair.second 访问 值。

C++ 无序多重映射方法

以下是一些最常用的无序多重映射方法

向无序多重映射添加元素

我们可以使用 insert() 函数向无序多重映射添加元素。例如，

#include <iostream>
#include <unordered_map>
using namespace std;

int main() {

    unordered_multimap<string, int> my_unordered_multimap;

    // insert single key-value pairs
    my_unordered_multimap.insert({"apple", 5});
    my_unordered_multimap.insert({"banana", 3});

    // insert multiple key-value pairs
    my_unordered_multimap.insert({{"apple", 2}, {"cherry", 4}});


    // print the unordered multimap
    cout << "Elements inserted into unordered multimap:" << endl;
    for (const auto& pair : my_unordered_multimap) {
        cout << pair.first << " -> " << pair.second << endl;
    }

    return 0;
}

输出

Elements inserted into unordered multimap:
cherry -> 4
banana -> 3
apple -> 5
apple -> 2

在无序多重映射中查找键

我们可以使用 find() 函数查找具有特定键的元素。

find() 函数返回

• 如果 找到键，则返回指向该元素的迭代器
• 如果 未找到键，则返回指向容器末尾的迭代器

例如，

#include <iostream>
#include <unordered_map>
using namespace std;

int main() {

    unordered_multimap<string, int> my_unordered_multimap;

    my_unordered_multimap.insert({"apple", 5});
    my_unordered_multimap.insert({"banana", 3});
    my_unordered_multimap.insert({"apple", 2});
    my_unordered_multimap.insert({"cherry", 4});

    // find elements with the key "apple"
    string key_to_find = "apple";
    auto found = my_unordered_multimap.find(key_to_find);

    // print the found key
    if (found != my_unordered_multimap.end()) {
        cout << "Found key " << key_to_find << ": " << endl;
        cout << found->first << " - " << found->second << endl;
    }
    else {
        cout << "Key " << key_to_find << " not found." << endl;
    }

    return 0;
}

输出

Found key apple: 
apple - 5

从示例可以看出，find() 函数仅返回多重映射中该键的第一个实例。

计算键的出现次数

我们可以使用 count() 函数计算特定键的出现次数。例如，

#include <iostream>
#include <unordered_map>

using namespace std;

int main() {

    unordered_multimap<string, int> my_unordered_multimap;

    my_unordered_multimap.insert({"apple", 5});
    my_unordered_multimap.insert({"banana", 3});
    my_unordered_multimap.insert({"apple", 2});
    my_unordered_multimap.insert({"cherry", 4});

    // count the number of elements with a specific key
    string key_to_count = "apple";
    int count = my_unordered_multimap.count(key_to_count);
    cout << "Count of key " << key_to_count << ": " << count << endl;

    return 0;
}

输出

Count of key apple: 2

在这里，我们使用 count() 函数计算键 apple 的值的数量。该函数返回 2，这意味着有两个具有此键的值。

检查无序多重映射的大小

我们可以使用 empty() 函数检查多重映射是否为空，并使用 size() 函数计算其大小。

empty() 函数返回

• true - 如果多重映射为空。
• false - 如果多重映射不为空。

并且，size() 函数返回多重映射中的元素数量。例如，

#include <iostream>
#include <unordered_map>
using namespace std;

int main() {

    unordered_multimap<string, int> my_unordered_multimap;
    
    // check capacity before insertion
    string result = my_unordered_multimap.empty()? "Yes" : "No";
    int multimap_size =  my_unordered_multimap.size();

    cout << "Before Insertion";
    cout << "\nIs unordered_multimap empty? " << result << endl;
    cout << "unordered_multimap size: " << multimap_size << endl;
        
    // insert element
    my_unordered_multimap.insert({"apple",2});
    
    // check capacity after insertion
    result = my_unordered_multimap.empty()? "Yes" : "No";
    multimap_size = my_unordered_multimap.size();

    cout << "\nAfter Insertion" << endl;
    cout << "\Is unordered_multimap empty? " << result << endl;
    cout << "unordered_multimap size: " << multimap_size << endl;
    
    return 0;
}

输出

Before Insertion
Is unordered_multimap empty? Yes
unordered_multimap size: 0

After Insertion
Is unordered_multimap empty? No
unordered_multimap size: 1

在这里，使用 三元运算符，result 变量存储字符串

• 如果多重映射为空（即，当 empty() 返回 true 时），则为 Yes
• 如果多重映射不为空（即，当 empty() 返回 false 时），则为 Yes

从无序多重映射中删除元素

我们可以使用以下函数从无序多重映射中删除元素

• erase() - 从多重映射中删除键的所有实例
• clear() - 删除多重映射中的所有元素

#include <iostream>
#include <unordered_map>
using namespace std;

int main() {

    unordered_multimap<string, int> my_unordered_multimap;

    my_unordered_multimap.insert({"apple", 5});
    my_unordered_multimap.insert({"banana", 3});
    my_unordered_multimap.insert({"apple", 2});
    my_unordered_multimap.insert({"cherry", 4});

    // erase elements with the key "apple"
    string key_to_erase = "apple";
    my_unordered_multimap.erase(key_to_erase);

    cout << "Elements after erasing key " << key_to_erase << ":" << endl;
    for (const auto& pair : my_unordered_multimap) {
        cout << pair.first << " -> " << pair.second << endl;
    }

    // clear the entire unordered_multimap
    my_unordered_multimap.clear();

    cout << "Elements after clearing:" << endl;
    for (const auto& pair : my_unordered_multimap) {
        cout << pair.first << " -> " << pair.second << endl;
    }

    return 0;
}

输出

Elements after erasing key apple:
cherry -> 4
banana -> 3
Elements after clearing: