Multimapa de pares en C++ con ejemplos

¿Qué es un multimapa?

En C++ , un mapa múltiple es un contenedor asociativo que se usa para almacenar elementos en forma de mapa. Internamente, un mapa múltiple se implementa como un árbol rojo-negro . Cada elemento de un mapa múltiple se trata como un par. El primer valor se denomina clave y el segundo valor se denomina valor. Multimapa es bastante similar a un mapa, pero en el caso de un multimapa, podemos tener varias claves iguales. Además, no podemos usar corchetes ([]) para acceder al valor asignado con una clave. Al igual que un mapa, las claves del mapa múltiple se ordenan en orden ascendente de forma predeterminada.

Funciones asociadas a multimapa:

  • begin() : Devuelve un iterador al primer elemento en el mapa múltiple
  • end() : Devuelve un iterador al elemento teórico que sigue al último elemento en el mapa múltiple
  • size() : Devuelve el número de elementos en el mapa múltiple
  • max_size() : Devuelve el número máximo de elementos que el mapa múltiple puede contener
  • vacío() : devuelve si el multimapa está vacío
  • insert(key, value) : Agrega un nuevo elemento o par al mapa múltiple
  • erase(posición del iterador) : Elimina el elemento en la posición señalada por el iterador
  • erase(const x) : Elimina el valor-clave ‘x’ del mapa múltiple
  • clear() : Elimina todos los elementos del mapa múltiple

¿Qué es un par?

El encabezado de utilidad en C++ nos proporciona un contenedor de pares . Un par consta de dos elementos de datos u objetos.

  • Se hace referencia al primer elemento como ‘primero’ y al segundo elemento como ‘segundo’ y el orden es fijo (primero, segundo).
  • Par se utiliza para combinar dos valores que pueden ser de tipo diferente. Pair proporciona una forma de almacenar dos objetos heterogéneos como una sola unidad.
  • El par se puede asignar, copiar y comparar. La array de objetos asignados en un mapa o hash_map es de tipo ‘par’ por defecto en el que todos los ‘primeros’ elementos son claves únicas asociadas con sus ‘segundos’ objetos de valor.

Para acceder a los elementos, usamos el nombre de la variable seguido del operador de punto seguido de la palabra clave primero o segundo.

¿Cómo acceder a un par?

Se puede acceder a los elementos de un par usando el operador de punto (.).

Sintaxis:

auto fistElement = miPar.primero;

auto fistElement = miPar.segundo;

Multimapa de pares

Un mapa múltiple de pares es un mapa múltiple en el que la clave o el valor es un par en sí mismo. Se considera que dos pares son iguales si el primero y el segundo elementos correspondientes de los pares son iguales. Ahora, si es necesario almacenar más de una copia de un par junto con otros elementos que también están ordenados o en un orden particular, en tales casos, el conjunto múltiple de pares resulta útil.

Sintaxis:

multimap<par<tipo de datos1, tipo de datos2>> myMultimap;

Aquí,

dataType1 y dataType2 pueden ser tipos de datos similares o diferentes.

Ejemplo 1: A continuación se muestra el programa C++ para demostrar el funcionamiento de un mapa múltiple de pares. 

C++

// C++ program to demonstrate
// the working of a multimap of
// pairs.
#include <bits/stdc++.h>
using namespace std;
  
// Function to print multimap elements
void print(multimap<pair<int, int>, 
           bool>& myContainer)
{
    cout << "Key(pair of integers)" << 
            "            " << 
            "Value(boolean)\n\n";
  
    for (auto pr : myContainer)  
    {
        pair<int, int> myPair = pr.first;
  
        // pr points to current pair of myContainer
        cout << '[' << myPair.first << " , " << 
                myPair.second << ']' << 
                "                                 " << 
                pr.second << '\n';
    }
}
  
// Driver code
int main()
{
    // Declaring a multimap
    // Key is of pair<int, int> type
    // Value is of bool type
    multimap<pair<int, int>, bool> myContainer;
  
    // Creating some pairs to be used
    // as keys
    pair<int, int> pair1;
    pair1 = make_pair(100, 200);
  
    pair<int, int> pair2;
    pair2 = make_pair(200, 300);
  
    pair<int, int> pair3;
    pair3 = make_pair(300, 400);
  
    pair<int, int> pair4;
    pair4 = make_pair(100, 200);
  
    // Since each element is a pair on 
    // its own in a multimap. So, we 
    // are inserting a pair
    // Note that [] operator doesn't working 
    // in case of a multimap
    myContainer.insert(pair<pair<int, int>, 
                       bool>(pair1, true));
    myContainer.insert(pair<pair<int, int>, 
                       bool>(pair2, false));
    myContainer.insert(pair<pair<int, int>, 
                       bool>(pair3, true));
    myContainer.insert(pair<pair<int, int>, 
                       bool>(pair4, false));
  
    // Calling print function
    print(myContainer);
  
    return 0;
}
Producción

Clave (par de enteros) Valor (booleano)

[100, 200] 1
[100, 200] 0
[200, 300] 0
[300, 400] 1

Ejemplo 2: A continuación se muestra el programa C++ para demostrar el funcionamiento de un mapa múltiple de pares.

C++

// C++ program to demonstrate
// the working of a multimap of
// pairs.
#include <bits/stdc++.h>
using namespace std;
  
// Function to print multimap elements
void print(multimap<pair<string, int>, 
           bool>& myContainer)
{
    cout << "Key(pair of integers)" << 
            "            " << 
            "Value(boolean)\n\n";
  
    for (auto pr : myContainer) 
    {
        pair<string, int> myPair = pr.first;
  
        // pr points to current pair of myContainer
        cout << '[' << myPair.first << 
                " , " << myPair.second << 
                ']' << "                " << 
                "                 " << 
                pr.second << '\n';
    }
}
  
// Driver code
int main()
{
    // Declaring a multimap
    // Key is of pair<int, int> type
    // Value is of bool type
    multimap<pair<string, int>, bool> myContainer;
  
    // Creating some pairs to be used
    // as keys
    pair<string, int> pair1;
    pair1 = make_pair("GFG", 100);
  
    pair<string, int> pair2;
    pair2 = make_pair("C++", 200);
  
    pair<string, int> pair3;
    pair3 = make_pair("CSS", 300);
  
    pair<string, int> pair4;
    pair4 = make_pair("GFG", 400);
  
    // Since each element is a pair on its 
    // own in a multimap. So, we are 
    // inserting a pair
    // Note that [] operator doesn't working 
    // in case of a multimap
    myContainer.insert(pair<pair<string, int>, 
                       bool>(pair1, true));
    myContainer.insert(pair<pair<string, int>, 
                       bool>(pair2, false));
    myContainer.insert(pair<pair<string, int>, 
                       bool>(pair3, true));
    myContainer.insert(pair<pair<string, int>, 
                       bool>(pair4, false));
  
    // Calling print function
    print(myContainer);
  
    return 0;
}
Producción

Clave (par de enteros) Valor (booleano)

[C++, 200] 0
[CSS, 300] 1
[GFG, 100] 1
[GFG, 400] 0

Publicación traducida automáticamente

Artículo escrito por bhuwanesh y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *