unordered_multimap y su aplicación

Permite duplicados: 
hemos discutido unordered_map en nuestra publicación anterior , pero hay una limitación, no podemos almacenar duplicados en unordered_map, es decir, si ya tenemos un par clave-valor en nuestro unordered_multimap y se inserta otro par, entonces ambos serán allí, mientras que en el caso de unordered_map, el valor anterior correspondiente a la clave se actualiza con el nuevo valor que solo estaría allí. Incluso puede existir en unordered_multimap dos veces.

Representación interna: 
la implementación interna de unordered_multimap es la misma que la de unordered_map pero para claves duplicadas, se mantiene otro valor de conteo con cada par clave-valor. Como los pares se almacenan en la tabla hash, no hay un orden particular entre ellos, pero los pares con las mismas claves se unen en la estructura de datos, mientras que no se garantiza que los pares con los mismos valores se unan. 

Complejidad del tiempo: 
todas las operaciones en unordered_multimap toman una cantidad de tiempo constante en promedio, pero el tiempo puede volverse lineal en el peor de los casos dependiendo de la función hash utilizada internamente, pero a largo plazo unordered_multimap supera a multimap (multimapa basado en árbol). 

Funciones: 
unordered_multimap admite muchas funciones que se muestran en el siguiente código: 

// C++ program to demonstrate various function of
// unordered_multimap
#include <bits/stdc++.h>
using namespace std;
 
// making typedef for short declaration
typedef unordered_multimap<string, int>::iterator unit;
 
// Utility function to print unordered_multimap
void printUmm(unordered_multimap<string, int> umm)
{
    // begin() returns iterator to first element of map
    unit it = umm.begin();
 
    for (; it != umm.end(); it++){
        cout << "<" << it->first << ", " << it->second
             << ">  ";
        cout << endl;
    }
}
 
// Driver code
int main()
{
    // empty initialization
    unordered_multimap<string, int> umm1;
 
    // Initialization by initializer list
    unordered_multimap<string, int> umm2(
        { { "apple", 1 },
          { "ball", 2 },
          { "apple", 10 },
          { "cat", 7 },
          { "dog", 9 },
          { "cat", 6 },
          { "apple", 1 } });
 
    // Initialization by assignment operation
    umm1 = umm2;
    printUmm(umm1);
 
    // empty returns true, if container is empty else it
    // returns false
    if (umm2.empty())
        cout << "unordered multimap 2 is empty\n";
    else
        cout << "unordered multimap 2 is not empty\n";
 
    // size returns total number of elements in container
    cout << "Size of unordered multimap 1 is "
         << umm1.size() << endl;
 
    string key = "apple";
 
    // find and return any pair, associated with key
    unit it = umm1.find(key);
    if (it != umm1.end()) {
        cout << "\nkey " << key << " is there in unordered "
             << " multimap 1\n";
        cout << "\none of the value associated with " << key
             << " is " << it->second << endl;
    }
    else
        cout << "\nkey " << key
             << " is not there in unordered"
             << " multimap 1\n";
 
    // count returns count of total number of pair
    // associated with key
    int cnt = umm1.count(key);
    cout << "\ntotal values associated with " << key
         << " are " << cnt << "\n\n";
 
    printUmm(umm2);
 
    // one insertion by making pair explicitly
    umm2.insert(make_pair("dog", 11));
 
    // insertion by initializer list
    umm2.insert({ { "alpha", 12 }, { "beta", 33 } });
    cout << "\nAfter insertion of <alpha, 12> and <beta, "
            "33>\n";
    printUmm(umm2);
 
    // erase deletes all pairs corresponding to key
    umm2.erase("apple");
    cout << "\nAfter deletion of apple\n";
    printUmm(umm2);
 
    // clear deletes all pairs from container
    umm1.clear();
    umm2.clear();
 
    if (umm2.empty())
        cout << "\nunordered multimap 2 is empty\n";
    else
        cout << "\nunordered multimap 2 is not empty\n";
}

<dog, 9>  
<cat, 6>  
<cat, 7>  
<ball, 2>  
<apple, 1>  
<apple, 10>  
<apple, 1>  
unordered multimap 2 is not empty
Size of unordered multimap 1 is 7

key apple is there in unordered  multimap 1

one of the value associated with apple is 1

total values associated with apple are 3

<dog, 9>  
<cat, 6>  
<cat, 7>  
<ball, 2>  
<apple, 1>  
<apple, 10>  
<apple, 1>  

After insertion of <alpha, 12> and <beta, 33>
<alpha, 12>  
<dog, 11>  
<dog, 9>  
<beta, 33>  
<cat, 6>  
<cat, 7>  
<ball, 2>  
<apple, 1>  
<apple, 10>  
<apple, 1>  

After deletion of apple
<alpha, 12>  
<dog, 11>  
<dog, 9>  
<beta, 33>  
<cat, 6>  
<cat, 7>  
<ball, 2>  

unordered multimap 2 is empty

Como podemos ver en el código anterior, la mayoría de las operaciones funcionan de manera similar a unordered_map, pero algunas cosas a tener en cuenta son: 
Podemos usar la lista de inicializadores para inicializar e insertar muchos pares a la vez. 
No hay un operador [] para unordered_multimap porque los valores correspondientes a una clave no son únicos, puede haber muchos valores asociados con una sola clave, por lo que no se les puede aplicar el operador []. 
La función de borrado elimina todas las instancias de valores asociados con la clave suministrada. 
La función de búsqueda devuelve un iterador a cualquier instancia de par clave-valor entre todos los pares asociados con esa clave. 

¿Cómo acceder/eliminar un valor específico para una clave?  
Si queremos verificar si un valor específico está allí o no, debemos recorrer todos los pares de clave-valor hasta que obtengamos nuestro valor específico, si obtenemos nuestro valor específico en unordered_multimap, use el método erase (posición) para eliminar ese valor específico de unordered_multimap. 

// C++ program to erase particular value.
#include <bits/stdc++.h>
using namespace std;
 
// Utility function to print unordered_multimap
void printUmm(unordered_multimap<string, int>& umm)
{
 
    // Iterator pointing to first element of unordered_map
    auto it1 = umm.begin();
 
    for (; it1 != umm.end(); it1++) {
        cout << "<" << it1->first << ", " << it1->second
             << ">  ";
        cout << endl;
    }
}
 
int main()
{
 
    // Initialization by intializer list
    unordered_multimap<string, int> umm{
        { "apple", 1 }, { "ball", 2 }, { "apple", 10 },
        { "cat", 7 },   { "dog", 9 },  { "cat", 6 },
        { "apple", 1 }
    };
 
    // Iterator pointing to first element of unordered_map
    auto it = umm.begin();
 
    // Search for an element with value 1
    while (it != umm.end()) {
        if (it->second == 1)
            break;
        it++;
    }
 
    // Erase the element pointed by iterator it
    if (it != umm.end())
        umm.erase(it);
     
      cout << "After deletion of value 1 from umm" << endl;
    printUmm(umm);
 
    return 0;
}

After deletion of value 1 from umm
<dog, 9>  
<cat, 6>  
<cat, 7>  
<ball, 2>  
<apple, 10>  
<apple, 1>  

Métodos de unordered_multimap: 

• begin() : devuelve un iterador que apunta al primer elemento del contenedor o al primer elemento de uno de sus cubos.
• end() : devuelve un iterador que apunta a la posición posterior al último elemento en el contenedor o a la posición posterior al último elemento en uno de sus cubos.
• count() : devuelve el número de elementos en el contenedor cuya clave es igual a la clave pasada en el parámetro.
• cbegin() : devuelve un iterador constante que apunta al primer elemento del contenedor o al primer elemento de uno de sus cubos.
• cend() : devuelve un iterador constante que apunta a la posición después del último elemento en el contenedor o a la posición después del último elemento en uno de sus cubos.
• clear() : borra el contenido del contenedor unordered_multimap.
• size() : devuelve el tamaño de unordered_multimap. Indica el número de elementos en ese contenedor.
• swap() : intercambia el contenido de dos contenedores unordered_multimap. Los tamaños pueden diferir de ambos contenedores.
• find() : devuelve un iterador que apunta a uno de los elementos que tienen la clave k.
• bucket_size() – Devuelve el número de elementos en el cubo n.
• vacío() : devuelve verdadero si el contenedor unordered_multimap está vacío. De lo contrario, devuelve falso.
• equal_range() : devuelve el rango en el que todas las claves del elemento son iguales a una clave.
• operator= – Copiar/Asignar/Mover elementos de diferentes contenedores.
• max_size() : devuelve el número máximo de elementos que puede contener el contenedor unordered_multimap.
• load_factor() : devuelve el factor de carga actual en el contenedor unordered_multimap.
• key_eq() – Devuelve un valor booleano según la comparación.
• emplace() : inserta una nueva {clave, elemento} en el contenedor unordered_multimap.
• emplace_hint() : inserta una nueva {clave:elemento} en el contenedor unordered_multimap.
• bucket_count() : devuelve el número total de cubos en el contenedor unordered_multimap.
• cubo() – Devuelve el número de cubo en el que se encuentra una clave determinada.
• max_load_factor() : devuelve el factor de carga máximo del contenedor unordered_multimap.
• rehash() : establece el número de cubos en el contenedor en N o más.
• reserve() : establece el número de cubos en el contenedor (bucket_count) en el número más apropiado para que contenga al menos n elementos.
• hash_function() : esta función hash es una función unaria que toma un solo argumento y devuelve un valor único de tipo size_t basado en él.
• max_bucket_count() : devuelve el número máximo de cubos que puede tener el contenedor multimapa desordenado.

Artículos recientes sobre unordered_multimap
Este artículo es una contribución de Utkarsh Trivedi. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.