web-dev-qa-db-fra.com

Complexité temporelle des méthodes HashMap

Depuis que je travaille sur la complexité temporelle, j'ai cherché dans la bibliothèque de classes Oracle Java la complexité temporelle de certaines méthodes standard utilisées sur les listes, les cartes et les classes. (Plus précisément, ArrayList , HashSet et HashMap)

Maintenant, quand on regarde les page javadoc HashMap , ils ne parlent vraiment que des méthodes get() et put().

Les méthodes que je dois encore connaître sont:

remove(Object o)
size()
values()

Je pense que remove() sera de la même complexité que get(), O(1), en supposant que nous n'avons pas de HashMap géant avec des hashCodes égaux, etc etc ...

Pour size() je suppose également O(1), car un HashSet, qui n'a pas non plus d'ordre, a une méthode size() avec complexité O(1) .

Celui que je n'ai aucune idée est values() - Je ne suis pas sûr si cette méthode va simplement "copier" le HashMap, donnant une complexité temporelle de O(1), ou si elle le fera doivent parcourir le HashMap, ce qui rend la complexité égale à la quantité d'éléments stockés dans le HashMap.

Merci.

javamethodshashmaptime-complexity
22
Koeneuze

La source est souvent utile: http://kickjava.com/src/Java/util/HashMap.Java.htm

  • remove: O (1)
  • size: O (1)
  • values: O(n) (en traversant l'itérateur)
25
b_erb

Le code pour supprimer (comme dans rt.jar pour HashMap) est:

/**
 * Removes and returns the entry associated with the specified key
 * in the HashMap.  Returns null if the HashMap contains no mapping
 * for this key.
 */
final Entry<K,V> removeEntryForKey(Object key) {
    int hash = (key == null) ? 0 : hash(key.hashCode());
    int i = indexFor(hash, table.length);
    Entry<K,V> prev = table[i];
    Entry<K,V> e = prev;

    while (e != null) {
        Entry<K,V> next = e.next;
        Object k;
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k)))) {
            modCount++;
            size--;
            if (prev == e)
                table[i] = next;
            else
                prev.next = next;
            e.recordRemoval(this);
            return e;
        }
        prev = e;
        e = next;
    }

    return e;
}

De toute évidence, le pire des cas est O (n).

5
JavaGuy

Recherche: O (1 + k/n)
Insérer: O (1)
Supprimer: O (1 + k/n) où k est le non. d'éléments de collision ajoutés à la même LinkedList (k éléments avaient le même hashCode)

L'insertion est O(1) parce que vous ajoutez l'élément juste en tête de LinkedList.

La complexité du temps amorti est proche de O(1) étant donné une bonne fonction de hachage. Si vous êtes trop préoccupé par le temps de recherche, essayez de résoudre les collisions à l'aide d'un BinarySearchTree au lieu de l'implémentation par défaut de Java ie LinkedList

1
Srujan Kumar Gulla

Vous pouvez toujours consulter le code source et le vérifier vous-même.
Quoi qu'il en soit ... J'ai une fois vérifié le code source et je me souviens qu'il y a une variable nommée size qui contient toujours le nombre d'éléments dans le HashMap donc size() est O(1).

1
Itay Karo