web-dev-qa-db-fra.com

Complexité temporelle de Java PriorityQueue (tas) insertion de n éléments?

Je voudrais savoir quelle est la complexité temporelle de Java PriorityQueue.Add() pour n éléments.

Je comprends que l'insertion potentielle dans le pire des cas, un seul élément est O(log(n)), mais je ne sais pas quelle est la complexité temporelle de l'insertion d'une collection d'éléments n?

J'ai vu des affirmations de diverses sources (sans preuves) que le temps de construire un tas de file d'attente prioritaire d'éléments n c'est O(n), et j'ai également vu des affirmations selon lesquelles c'est O(nlog(n)), ce qui est logique étant donné que l'insertion est O(log(n)), qui multiplie n fois serait en effet égal à O(nlog(n))

Remarque: je ne suis intéressé que dans le pire des cas, non amorti.

Cette question suppose qu'il existe un moyen logique de décrire l'acte de remplir une structure de données (tas) avec des éléments n, ce qui est différent de simplement considérer les insertions n x log(n) individuellement.

Je ne fais aucune hypothèse concernant l'entrée (comme des limites sur l'ensemble des valeurs d'entrée ou une entrée partiellement ordonnée).

javatime-complexityheappriority-queue
6
James Wierzba

C'est O (N log N) dans le cas général. Un algorithme O (N) existe pour le cas spécial où l'entrée est déjà ordonnée, mais cela n'est pas fourni dans Java.util.PriorityQueue.

1
user207421

Il semble que l'insertion de n éléments devrait être O (n log n)

Java PriorityQueue ( Java Doc )

O(log n) time for the enqueing and dequeing methods (offer, poll, remove() and add)

O (n) pour les méthodes remove (Object) et contient (Object)

O(1) for the retrieval methods (peek, element, and size)

Ces complexités temporelles semblent tout pires ( wiki ), à l'exception de .add(). Vous avez raison de remettre en question les limites comme l'indique le document Java Doc) à l'extension de cette structure non liée:

Les détails de la politique de croissance ne sont pas précisés

Comme ils l'indiquent également dans le Doc, la PriorityQueue est basée sur un tableau avec une capacité initiale spécifique. Je suppose que la croissance coûtera O(n) temps, ce qui serait alors le pire cas de complexité temporelle pour .add().

Pour obtenir un temps O (n log n) garanti pour l'ajout de n éléments, vous pouvez indiquer la taille de vos n éléments pour omettre l'extension du conteneur:

PriorityQueue(int initialCapacity)

EDIT: À la demande de O(n) le temps de construction est correct (comme indiqué par @pjs dans le Cette procédure est souvent appelée heapify et fonctionne sur un tableau préexistant qui est utilisé pour construire un arbre binaire dessus en O(n) time).

8
gue