Que signifie "temps d'accès O (1)"?
J'ai vu que ce terme "temps d'accès O (1)" signifiait "rapidement" mais je ne comprends pas ce que cela signifie. L'autre terme que je vois avec dans le même contexte est "O (n) access time". Quelqu'un pourrait-il s'il vous plaît expliquer d'une manière simple ce que signifient ces termes?
Voir aussi
Vous allez vouloir lire sur Ordre de complexité.
http://en.wikipedia.org/wiki/Big_O_notation
En bref, O(1) signifie qu'il faut un temps constant, par exemple 14 nanosecondes, ou trois minutes, quelle que soit la quantité de données de l'ensemble.
O (n) signifie qu'il faut une durée linéaire avec la taille de l'ensemble, de sorte qu'un ensemble deux fois plus grand prend deux fois plus de temps. Vous ne voulez probablement pas mettre un million d'objets dans l'un d'entre eux.
En substance, cela signifie qu'il faut autant de temps pour rechercher une valeur dans votre collection, que vous disposiez d'un petit nombre d'éléments dans votre collection ou de quantités très importantes (dans les limites des contraintes de votre matériel).
O (n) signifierait que le temps nécessaire pour rechercher un élément est proportionnel au nombre d'éléments de la collection.
Des exemples typiques de ceux-ci sont les tableaux, auxquels on peut accéder directement, quelle que soit leur taille, et les listes chaînées, qui doivent être parcourues dans l'ordre afin, depuis le début, d'accéder à un élément donné.
L'autre opération habituellement discutée est l'insertion. Une collection peut être O(1) pour l'accès mais O(n) pour l'insertion. En fait, un tableau a exactement ce comportement car il insère un élément Au milieu, vous devrez déplacer chaque élément vers la droite en le copiant dans l'emplacement suivant.
Chaque réponse qui répond actuellement à cette question vous indique que la O(1) signifie un temps constant (quelle que soit l'évolution de la mesure; cela peut être le temps d'exécution, le nombre d'opérations, etc.). Ceci n'est pas exact.
Dire que le runtime est O(1) signifie qu'il existe une constante c telle que le runtime est limité ci-dessus par c, indépendamment de l'entrée. Par exemple, renvoyer le premier élément d'un tableau de n entiers est O(1):
int firstElement(int *a, int n) {
return a[0];
}
Mais cette fonction est aussi O(1):
int identity(int i) {
if(i == 0) {
sleep(60 * 60 * 24 * 365);
}
return i;
}
La durée d'exécution ici est limitée au-dessus d'un an, mais la plupart du temps, elle est de l'ordre de la nanoseconde.
Dire que le runtime est O(n) signifie qu'il existe une constante c telle que le runtime soit délimité par c * n, Où n mesure la taille de l'entrée. Par exemple, pour rechercher le nombre d'occurrences d'un entier particulier dans un tableau non trié d'entiers n à l'aide de l'algorithme suivant, vous obtenez O(n):
int count(int *a, int n, int item) {
int c = 0;
for(int i = 0; i < n; i++) {
if(a[i] == item) c++;
}
return c;
}
En effet, nous devons parcourir le tableau en inspectant chaque élément un par un.
O (1) signifie que le temps d'accès à quelque chose est indépendant du nombre d'éléments de la collection.
O (N) signifie que le temps d'accès à un élément est proportionnel au nombre (N) d'éléments de la collection.
O (1) ne signifie pas nécessairement "rapidement". Cela signifie que le temps nécessaire est constant et que not est basé sur la taille de l'entrée de la fonction. Constant pourrait être rapide ou lent. O(n) signifie que le temps que prendra la fonction changera proportionnellement à la taille de l'entrée de la fonction, indiquée par n. deviendra plus lent lorsque la taille de n augmente.
Il s'appelle notation Big O et décrit le temps de recherche de divers algorithmes.
O (1) signifie que le temps d'exécution dans le cas le plus défavorable est constant. Dans la plupart des cas, cela signifie que vous n’avez pas réellement besoin de chercher dans la collection, vous pouvez trouver ce que vous cherchez tout de suite.
La "notation Big O" est un moyen d’exprimer la vitesse des algorithmes. n est la quantité de données utilisée par l'algorithme. O(1) signifie que, quelle que soit la quantité de données, elle s'exécutera en temps constant. O(n) signifie qu'il est proportionnel à la quantité de données.
O(1) est toujours exécuté dans le même temps, quel que soit le jeu de données n. Un exemple de O(1) serait un ArrayList accédant à son élément avec index.
O(n) également connu sous le nom d'ordre linéaire, les performances augmentent linéairement et proportionnellement à la taille des données d'entrée. Un exemple de O(n)) serait une insertion et une suppression de ArrayList à une position aléatoire. tableau afin de maintenir sa structure linéaire, sans parler de la création d’un nouveau tableau et de la copie d’éléments de l’ancien au nouveau tableau, ce qui prend un temps de traitement coûteux et nuit donc aux performances.
Fondamentalement, O(1) signifie que son temps de calcul est constant, alors que O(n) signifie que cela dépendra linéairement sur la taille de l'entrée - c'est-à-dire que la boucle dans un tableau a O(n) - simplement en boucle -, car cela dépend du nombre d'éléments, lors du calcul le maximum entre les nombres ordinaires a O (1).
Wikipedia pourrait aussi aider: http://en.wikipedia.org/wiki/Computational_complexity_theory
Le moyen le plus simple de différencier O(1) et O(n) est en comparant tableau et liste.
Pour array, si vous avez la bonne valeur d'index, vous pouvez accéder aux données instantanément. (Si vous ne connaissez pas l'index et que vous devez parcourir le tableau, il ne s'agira plus de O(1))
Pour une liste, vous devez toujours le parcourir, que vous connaissiez l’index ou non.
Cela signifie que le temps d'accès est constant. Que vous accédiez à 100 ou 100 000 enregistrements, le temps de récupération sera le même.
En revanche, le temps d'accès O(n)) indique que le temps de récupération est directement proportionnel au nombre d'enregistrements auxquels vous accédez.
Cela signifie que l'accès prend un temps constant, c'est-à-dire qu'il ne dépend pas de la taille de l'ensemble de données. O(n) signifie que l'accès dépendra de la taille de l'ensemble de données de manière linéaire.
Le O est également connu sous le nom de Big-O.
Voici une analogie simple; Imaginez que vous téléchargez des films en ligne avec O (1). S'il faut 5 minutes pour télécharger un film, il faudra tout de même autant de temps pour télécharger 20 films. Ainsi, peu importe le nombre de films que vous téléchargez, ils prendront le même temps (5 minutes) qu’il s’agisse d’un ou de 20 films. Un exemple normal de cette analogie est lorsque vous allez dans une bibliothèque de films, que vous preniez un film ou 5, vous devez simplement les sélectionner en une fois. Donc passer le même temps.
Cependant, avec O (n), s'il faut 5 minutes pour télécharger un film, il faudra environ 50 minutes pour télécharger 10 films. Le temps n’est donc pas constant ou proportionnel au nombre de films que vous téléchargez.
Introduction aux algorithmes: Deuxième édition de Cormen, Leiserson, Rivest & Stein indique à la page 44 que
Comme toute constante est un polynôme de degré 0, nous pouvons exprimer toute fonction de constante sous la forme Theta (n ^ 0) ou Theta (1). Cette dernière notation est toutefois un abus mineur, car il est difficile de savoir quelle variable tend vers l'infini. Nous utiliserons souvent la notation Theta (1) pour désigner une fonction constante ou constante par rapport à une variable. ... On note O (g (n)) ... l'ensemble des fonctions f(n) telles qu'il existe des constantes positives c et n0 telles que 0 <= f(n) <= c * g (n) pour tout n> = n0. ... Notez que f(n) = Thêta (g (n)) ) implique f(n) = O (g (n)) ", car la notation Thêta est supérieure à la notation 0.
Si un algorithme s'exécute dans le temps O(1), cela signifie que asymptotiquement ne dépend d'aucune variable, ce qui signifie qu'il existe au moins une constante positive qui, multipliée par un, est supérieure à la complexité asymptotique (~ durée d'exécution) de la fonction pour des valeurs de n supérieures à une certaine valeur. Techniquement, il s'agit du temps O (n ^ 0).