1
votes

comment un unordered_map est initialisé avec les valeurs de array

Je suis tombé sur un code où je suis confus, un unordered_map est initialisé comme ci-dessous

int arr[] = { 1, 5, 2, 1, 3, 2, 1 };
unordered_map<int, int> hash; 
    for (int i = 0; i < n; i++) 
        hash[arr[i]]++;

Mais ce qui me surprend, c'est le code ci-dessous

std::unordered_map<std::string, int> wordMap;

// Inserting elements through an initializer_list
wordMap.insert({ {"First", 1}, {"Second", 2}, {"Third", 3} } );

c++ c++11 hashmap

0 commentaires

3 Réponses :

0
votes

L'opérateur [] vérifie si l'élément existe. Si ce n'est pas le cas, il en crée un en utilisant le constructeur par défaut et retourne une référence (ou une référence const). c'est-à-dire:

hash[1]=3
hash[2]=2
hash[3]=1
hash[5]=1

qui est

hash[1]++ => hash[1]=hash[1]+1 which is 0+1 ( since hash[1] at the begining was 0 by default.. )
when it get to the second 1 it become hash[1]=hash[1]+1 = 2 ...

..ect same for other values

en gros, il crée et compte le nombre de doublons dans le tableau

à la fin, il vous donne

 hash[arr[0]]++
 it creates hash[1]first

0 commentaires

1
votes

Ici, dans unordered_map , hash [arr [i]] ++; fonctionne de cette manière:

Il recherche une clé (arr [i]). S'il est trouvé, la valeur correspondante est incrémentée de 1 .
S'il n'est pas trouvé, un nouvel élément sera créé avec la clé arr [i] et comme la valeur est de type int , la valeur par défaut de 0 est stocké pour cela. En raison de l'opérateur ++ , il sera incrémenté de un. Ainsi, à la fin de l'opération, la valeur sera 1.

Pour être très explicite pour votre exemple, cela fonctionne comme ceci:

i = 0 => arr[i] = 1 => Not present in map => New pair added => hash: [{1, 1}]
i = 1 => arr[i] = 5 => Not present in map => New pair added => hash: [{1, 1}, {5, 1}]
i = 2 => arr[i] = 2 => Not present in map => New pair added => hash: [{1, 1}, {5, 1}, {2, 1}]
i = 3 => arr[i] = 1 => Present in map => Existing pair updated => hash: [{1, 2}, {5, 1}, {2, 1}]
i = 4 => arr[i] = 3 => Not present in map => New pair added => hash: [{1, 2}, {5, 1}, {2, 1}, {3, 1}]
i = 5 => arr[i] = 2 => Present in map => Existing pair updated => hash: [{1, 2}, {5, 1}, {2, 2}, {3, 1}]
i = 6 => arr[i] = 1 => Present in map => Existing pair updated => hash: [{1, 3}, {5, 1}, {2, 2}, {3, 1}]

L'ordre mentionné ici peut être différent de l'ordre réel. L'explication ci-dessus est juste pour expliquer les choses.

1 commentaires

@TuhinPanda Est-ce que cela répond à votre question?

0
votes

La clé de la carte non ordonnée doit être unique pour que tous les 1: s soient combinés. Mais quand ils se combinent, la boucle ajoutera 1 au côté valeur:

hash [arr [i]] ++ sera égal à cet exemple: hash [1] + = 1;

Puisqu'il y a trois valeurs 1, hash [1] finira avec une valeur de 3. Vous trouverez deux enregistrements de la valeur 2 et cela fera hash [2] = 2. p >

#include <iostream>
#include <unordered_map>

int main()
{
    int arr[] = { 1, 5, 2, 1, 3, 2, 1 };
    std::unordered_map<int, int> hash; 
    for (int i = 0; i < 7; i++) {
        hash[arr[i]] += 1;
    }
    for (auto i : hash) {
        printf("%i:%i\n", i.first, i.second);
    }
}
# Output:
#   3:1
#   2:2
#   5:1
#   1:3

0 commentaires