c++ - ordenado - Verificar si un elemento existe o no en el mapa dentro del mapa

mapas hash java

Question

Tengo un mapa del mapa de formulario map<key1, map<key2, value> > :

Por ejemplo: estoy almacenando el valor de intensidad en la coordenada 2-D (x, y) en el siguiente mapa:

map<int, map<int, double> > intensityValue;

Ahora, quiero verificar si el valor de intensidad en la coordenada (x, y) existe en este mapa o no. Una forma que conozco es verificar:

if(intensityvalue[x][y] >=0)

en este caso, si intensityValue[x][y] no existe en el mapa y luego de verificarlo automáticamente insertará intensityValue[x][y] en el mapa que no quiero .

Sugiera una forma eficiente para que pueda verificar si intensityValue[x][y] ya existe en el mapa o no, sin insertarlo en el mapa.

Answer 1

Escriba una función breve para garantizar que se llame al número mínimo de búsqueda de mapas.

bool hasIntensity(int x, int y)
{
    map<int, map<int, double> >::const_iterator i = intensityValue.find(x);
    if (i == intensityValue.end()) return false;
    map<int, double>::const_iterator j = i->second.find(y);
    return j != (i->second.end());
}

Si desea obtener el valor real cuando se encuentra el elemento, simplemente utilice j->second .

Answer 2

Esto es un poco feo pero debería funcionar también: (usando C ++ 11)

std::map<int, std::map<int, double> > intensityValue;
int x,y;
auto it = std::find_if(intensityValue.begin(),
                    intensityValue.end(),
                    [x,y](const std::pair<int, std::map<int, double>>& p){
                      return p.first==x && 
                             p.second.find(y) !=p.second.end();
                    }
                    );

  if(it != intensityValue.end())
  {
      //Got it !
  } 

Answer 3

Puede usar std::map::find junto con la evaluación de cortocircuito:

bool foundXY = instensityValue.find(x) != intensityValue.end() &&
               intensityValue[x].find(y) != intensityValue[x].end();

o std::map::count :

bool foundXY = instensityValue.count(x) && intensityValue[x].count(y)

Answer 4

Puede usar std::map::find y verificar si el elemento existe antes de acceder a él. Puede leer el uso / documentación aquí: http://en.cppreference.com/w/cpp/container/map/find

Answer 5

Utilice std::map::find

auto outerIt = intensityValue.find(x);
if (outerIt != intensityValue.end()) {
    auto innerIt = outerIt->find(y);
    if (innerIt != outerIt->end()) {
        // Do something with the found value
        return;
    }
}
// Didn''t return, so it wasn''t found

Dicho esto, en mi experiencia, usar un solo mapa de pares para este tipo de cosas es más eficiente y más fácil de usar que un mapa anidado. Se adapta mejor a los algoritmos estándar y no implica casi tanta navegación en árbol.

template <typename T, typename U, typename V>
using map2d = std::map<std::pair<T, U>, V>;

int main() {
    map2d<int, int, double> myMap {
        {{3, 4}, 808.14f},
        {{1, 2}, 333.33f}
    };
    auto it = myMap.find({3, 4});
    if (it != myMap.end()) {
        std::cout << it->second << std::endl;
    }
}