unordered_map igual_rango en C++

Unordered_map::equal_range() es una función incorporada en C++ STL que se usa para devolver los límites de un rango que incluye todos los elementos en el contenedor con una clave que se compara igual a k. Los contenedores unordered_map son el contenedor donde las claves son únicas, el rango incluirá un elemento como máximo. El rango está definido por dos iteradores,

  • El primero apuntando al primer elemento del rango.
  • El segundo apunta más allá del último elemento del rango.

Parámetros: esta función acepta una sola tecla de parámetro que se utiliza para mantener el valor a comparar.

Valor devuelto: Devuelve un par que contiene un par de iteradores que definen el rango deseado. Donde sus miembros son par::primero y par::segundo. El primero es un iterador al límite inferior del rango y el segundo es un iterador a su límite superior. Los elementos del rango son los que se encuentran entre estos dos iteradores, incluido el primer par, pero no el segundo.

Los siguientes programas ilustran la función unordered_map::equal_range() en C++ STL:

Ejemplo 1:

// C++ program to implement 
// unordered_map::equal_range() function
#include <iostream>
#include <unordered_map>
using namespace std;
  
// main program
int main()
{
    unordered_map <int, int> map = { { 1, 3 }, 
                                     { 1, 2 }, 
                                     { 3, 1 }, 
                                     { 2, 3 } };
    for (int j = 1; j <= 3; j++) {
        auto range = map.equal_range(j);
          
        //'auto' is a keyword
        for (auto i = range.first; i != range.second; i++) {
              
            // iterates first to last
            cout << "first : " << i->first;
            cout << "\nsecond : " << i->second << endl
                << endl;
        }
    }
}
Producción:

first : 1
second : 3

first : 2
second : 3

first : 3
second : 1

Programa 2:

// C++ program to search 'unordered map' container
#include <iostream>
#include <unordered_map>
using namespace std;
  
// Rename 'unordered_map<int, char>' as 'gfg'
typedef unordered_map<char, char> gfg;
  
  
int main()
{
    // 'g' is object
    gfg g;
      
    // Container values
    // Contents are look like [a, b] [c, d] [e, f]
    g.insert(gfg::value_type('a', 'b'));
    g.insert(gfg::value_type('b', 'd'));
    g.insert(gfg::value_type('e', 'f'));
  
    // Look into the syntax part above
    // here 'f' is key
    pair<gfg::iterator, gfg::iterator> p1 = g.equal_range('f');
      
    // 'f' is not exits, so no output for 'f'
    cout << "search for 'f' :";
    for (; p1.first != p1.second; ++p1.first) {
        cout << p1.first->first << ", " << p1.first->second << endl;
    }
      
    // Successful search
    // Here 'a' is key
    p1 = g.equal_range('a');
      
    // 'a' is exits, so it searched successfully
    cout << "\nsearch for 'a' : [";
    for (; p1.first != p1.second; ++p1.first) {
        cout << p1.first->first << ", " << p1.first->second << "]";
    }
      
    return 0;
}
Producción:

search for 'f' :
search for 'a' : [a, b]

Complejidad:

  • Caso medio: Lineal en el número de elementos con la clave k, que es constante.
  • Peor caso: Lineal en el tamaño del contenedor.

Publicación traducida automáticamente

Artículo escrito por SoumikMondal 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 *