Unordered Multimap in C++ STL

In C++, the unordered_multimap is an unordered associative container that stores data in the form of key-value pairs. It is similar to unordered map, but it allows multiple elements with the same key. It provides fast insertion, deletion and search operations in O(1) time by using hashing.

Example:

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

int main() {
    
    // Creating an unordered_map with
    // integer keys and string values
    unordered_multimap<int, string> umm =
                   {{1, "Geeks"}, {2, "For"},
                   {3, "C++"}, {1, "STL"}};
    for (auto x : umm) 
        cout << x.first << ": " << x.second
        << endl;
    return 0;
}

3: C++
2: For
1: STL
1: Geeks

Explanation: In this example, we create an unordered multimap umm with four key value pairs: {1, "Geeks"}, {2, "For"}, {3, "C++"} and {1, "STL"}. We can see from the output that there is no order of the elements.

Syntax

Unordered map is defined as the std::unordered_multimap class template inside the <unordered_map> header file.

unordered_multimap<key_type, value_type, > umm;

where,

• key_type: Data type of key.
• value_type: Data type of value.
• umm: Name assigned to the unordered multimap.

Declaration and Initialization

Unordered multimap can be declared and initialized in multiple ways as shown in the below example:

#include <bits/stdc++.h>
using namespace std;

int main() {
    
    // Creating an empty unordered_multimap
    unordered_multimap<int, string> umm1;
    
    // Creating unordered_multimap using
    // initializer list
    unordered_multimap<int, string> umm2 =
    {{1, "Geeks"}, {2, "For"}, {1, "C++"}};

    for (auto x : umm2) 
        cout << x.first << ": " << x.second
        << endl;
    return 0;
}

1: C++
1: Geeks
2: For

Explanation: In the above example,

• Statement unordered_multimap<int, string> umm1 creates an empty multimap. This is also called default initialization.
• Statement unordered_multimap<int, string> umm2 = ({1, "Geeks"}, {2, "For"}, {3, "C++"}, {1, "STL"}) creates and initialize it using an initializer list.

Basic Operations

The basic operations on unordered multimap are shown below:

1. Inserting Elements

New key-value pairs can be inserted using the insert() function. This function allows inserting multiple elements with the same key. This map container does not support the use of [] operator because multiple elements with the same key can be present.

Example:

#include <bits/stdc++.h>
using namespace std;

int main() {
    unordered_multimap<int, string> umm;
    
    // Insert elements using insert()
    umm.insert({2, "For"});
    umm.insert({3, "C++"});
    umm.insert({2, "Geeks"});
    
    for (auto x : umm) 
        cout << x.first << ": "
        << x.second << endl;
    return 0;
}

3: C++
2: Geeks
2: For

2. Accessing Elements

Elements can be accessed by its position by moving begin() and end() iterators, but it is not useful. In unordered multimap, accessing value by their key is the primary operation. This can be done by using find() method.

Example:

#include <bits/stdc++.h>
using namespace std;

int main() {
    unordered_multimap<int, string> umm =
    {{2, "For"}, {3, "C++"}, {2, "Geeks"}};
    
    // Find 2nd element
    auto it = next(umm.begin(), 1);
    
    if (it != umm.end())
        cout << it->first << ": " <<
        it->second;
    else
        cout << "Element not found!";
    return 0;
}

2: For

3. Finding Elements

In unordered multimap, elements can be accessed by their key using find() method. This method searches for the given key and returns the iterator to the first element with the given key. This iterator can be dereferenced to access the key(first) and value(second) of the pair.

Example:

#include <bits/stdc++.h>
using namespace std;

int main() {
    unordered_multimap<int, string> umm =
    {{2, "For"}, {3, "C++"}, {2, "Geeks"}};
    
    // Searching for key '2' using find()
    auto it = umm.find(2);
    
    if (it != umm.end())
        cout << it->first << ": " <<
            it->second;
    else
        cout << "Element not Found!";
    return 0;
}

2: Geeks

4. Updating Elements

Unordered multimap allows users to update the associated value of any key. This can be done by accessing the element and assigning the new value (second member).

Example:

#include <bits/stdc++.h>
using namespace std;

int main() {
    unordered_multimap<int, string> umm =
    {{2, "For"}, {3, "C++"}, {2, "Geeks"}};
    
    // Searching for key '2' using find()
    auto it = umm.find(2);
    
    // Updating value
    it->second = "Java";
    
    for (auto x: umm)
        cout << x.first << ": " << x.second
        << endl;
    return 0;
}

2: Java
2: For
3: C++

5. Traversing

Traversing through an unordered multimap can be done using begin() or end() iterators or a range-based for loop.

Example:

#include <bits/stdc++.h>
using namespace std;

int main() {
    unordered_multimap<int, string> umm =
    {{1, "Geeks"},{2, "For"},{1, "C++"}};

    // Traversing using iterators with loop
    for(auto it = umm.begin(); it != umm.end(); it++)
        cout << it->first << ": " << it->second
        << endl;
    return 0;
}

1: C++
1: Geeks
2: For

Explanation: In the above program, traversal through the unordered multimap is done using an iterator with a loop. Starting from beginning, in each iteration, the iterator it points to a pair and then incremented. The traversal stops when it encounters the end() iterator.

6. Deleting Elements

Elements can be deleted using erase() by passing either the key or the iterator. If the key is passed, then all the elements with the same key are deleted.

#include <bits/stdc++.h>
using namespace std;

int main() {
    unordered_multimap<int, string> umm =
    {{1, "Geeks"}, {2, "For"},{3, "C++"},
                             {1, "STL"}};
    
    // Delete all elements which are 
    // associated with key 1
    umm.erase(1);
    
    // Delete first element
    // using iterator
    umm.erase(umm.begin());
    
    for(auto x: umm)
        cout << x.first << " " << x.second;
    return 0;
}

2 For

Time Complexity

The below table lists the time complexity of the above operations on unordered multimap:

Other Common Operations

The unordered multimap is used in various scenarios. The following examples help you master its advanced usage:

• Find the Size of Unordered Multimap
• Check if Unordered Multimap is Empty
• Count Frequency of Elements with Same Key
• Swap Two Unordered Multimap

Internal Working

An unordered multimap container provides the built-in implementation of a hash table. When an element is inserted, its key is hashed, and the hash value determines the index of the bucket at which the value is stored. Elements with the same hash value (i.e. with same keys) are stored in the same bucket. These buckets are generally implemented as linked lists. This allows for fast access and insertion, basically with constant time complexity O(1) for operations like insert(), erase(), and find(). However, due to hash collisions, the time complexity can degrade to O(n) in the worst case.

Unordered Multimap vs Unordered Map

The main difference between unordered multimap and unordered map is shown below:

• Unordered multimap allows multiple elements with the same key, making it ideal when multiple values for the same key are needed.
• Unordered map only allows one element per key, making it suitable for cases where unique key-value pairs are required.

All Member Functions

Following is the list of all member functions of std::unordered_multimap class in C++: