web-dev-qa-db-fra.com

Quelle est la complexité temporelle de l'indexation, de l'insertion et de la suppression des structures de données communes?

Il n'y a pas de résumé disponible de la grande notation O pour les opérations sur les structures de données les plus courantes, y compris les tableaux, les listes liées, les tables de hachage, etc.

data-structurescomplexity-theorybig-o
30
James

Des informations sur ce sujet sont désormais disponibles sur Wikipedia à l'adresse: structure de données de recherche

+----------------------+----------+------------+----------+--------------+
|                      |  Insert  |   Delete   |  Search  | Space Usage  |
+----------------------+----------+------------+----------+--------------+
| Unsorted array       | O(1)     | O(1)       | O(n)     | O(n)         |
| Value-indexed array  | O(1)     | O(1)       | O(1)     | O(n)         |
| Sorted array         | O(n)     | O(n)       | O(log n) | O(n)         |
| Unsorted linked list | O(1)*    | O(1)*      | O(n)     | O(n)         |
| Sorted linked list   | O(n)*    | O(1)*      | O(n)     | O(n)         |
| Balanced binary tree | O(log n) | O(log n)   | O(log n) | O(n)         |
| Heap                 | O(log n) | O(log n)** | O(n)     | O(n)         |
| Hash table           | O(1)     | O(1)       | O(1)     | O(n)         |
+----------------------+----------+------------+----------+--------------+

 * The cost to add or delete an element into a known location in the list (i.e. if you have an iterator to the location) is O(1). If you don't know the location, then you need to traverse the list to the location of deletion/insertion, which takes O(n) time. 
** The deletion cost is O(log n) for the minimum or maximum, O(n) for an arbitrary element.
65
Mobiletainment

Je suppose que je vais commencer par la complexité temporelle d'une liste chaînée:

Indexation ----> O (n)
Insertion/suppression à la fin ----> O (1) ou O (n)
Insertion/suppression au milieu ---> O (1) avec itérateur O(n) sans

La complexité temporelle de l'insertion à la fin dépend si vous avez l'emplacement du dernier nœud, si vous le faites, ce serait O(1) autrement, vous devrez rechercher dans le lien et la complexité temporelle passerait à O (n).

14
Jose Vega

Gardez à l'esprit qu'à moins que vous n'écriviez votre propre structure de données (par exemple une liste chaînée en C), cela peut dépendre considérablement de la mise en œuvre des structures de données dans votre langue/cadre de choix. À titre d'exemple, jetez un œil aux repères du CFArray d'Apple sur Ridiculous Fish . Dans ce cas, le type de données, un CFArray du framework CoreFoundation d'Apple, modifie en fait les structures de données en fonction du nombre d'objets dans le tableau, passant du temps linéaire au temps constant à environ 30000 objets.

C'est en fait l'une des belles choses sur la programmation orientée objet - vous n'avez pas besoin de savoir comment cela fonctionne, juste que cela fonctionne, et le 'comment ça marche' peut changer en fonction des besoins.

4
Dan Udey

Rien d'aussi utile que cela: Opérations de structure de données communes :

enter image description here

2
Pritam Banerjee

Arbres rouge-noir:

  • Insérer - O (log n)
  • Récupérer - O (log n)
  • Supprimer - O (log n)
2
Hank Gay

Big-O amorti pour les tables de hachage:

  • Insertion - O (1)
  • Récupérer - O (1)
  • Supprimer - O (1)

Notez qu'il existe un facteur constant pour l'algorithme de hachage, et l'amortissement signifie que les performances mesurées réelles peuvent varier considérablement.

1
Hank Gay