web-dev-qa-db-fra.com

Qu'est-ce que la complexité temporelle et comment la trouver?

J'ai lu tellement de ressources et je suis encore incapable de comprendre ce qu'est la complexité du temps. Les ressources que j'ai lues étaient basées sur diverses formules. J'ai compris que O(n) est utilisé pour exprimer la complexité temporelle, mais je ne sais pas comment. Quelqu'un pourrait-il m'expliquer ce principe d'une manière claire et compréhensible, s'il vous plaît.

javatime-complexity
5
Ilja

Référence: Comment calculer l'algorithme de complexité temporelle

J'ai trouvé un bon article sur Comment calculer la complexité temporelle de tout algorithme ou programme

La métrique la plus courante pour calculer la complexité temporelle est la notation Big O. Cela supprime tous les facteurs constants de sorte que le temps d'exécution puisse être estimé par rapport à N, lorsque N approche l'infini. En général, vous pouvez penser comme ça:

statement;

Est constant. La durée d'exécution de l'instruction ne changera pas par rapport àN.

for ( i = 0; i < N; i++ )
     statement;

Est linéaire. La durée d'exécution de la boucle est directement proportionnelle à N. Lorsque N double, il en va de même pour la durée d'exécution.

for ( i = 0; i < N; i++ ) {
  for ( j = 0; j < N; j++ )
    statement;
}

Est quadratique. La durée d'exécution des deux boucles est proportionnelle au carré de N. Lorsque N double, la durée d'exécution augmente de N * N. 

while ( low <= high ) {
  mid = ( low + high ) / 2;
  if ( target < list[mid] )
    high = mid - 1;
  else if ( target > list[mid] )
    low = mid + 1;
  else break;
}

Est logarithmique. Le temps d'exécution de l'algorithme est proportionnel au nombre de fois où N peut être divisé par 2. En effet, l'algorithme divise la zone de travail en deux à chaque itération.

void quicksort ( int list[], int left, int right )
{
  int pivot = partition ( list, left, right );
  quicksort ( list, left, pivot - 1 );
  quicksort ( list, pivot + 1, right );
}

Est N * log (N). Le temps d'exécution étant constitué de N boucles (itératives ou récursives) logarithmiques, l'algorithme est une combinaison de linéaire et de logarithmique.

En général, faire quelque chose avec chaque article dans une dimension est linéaire, faire quelque chose avec chaque article dans deux dimensions est quadratique, et diviser la surface de travail en deux est logarithmique. Il existe d'autres mesures Big O telles que cubique, exponentielle et racine carrée, mais elles ne sont pas aussi communes. La notation Big O est décrite comme O () où est la mesure. L'algorithme quicksort serait décrit comme O (N * log (N)).

Notez que rien de tout cela n'a pris en compte les mesures optimales, moyennes et pires. Chacun aurait sa propre notation Big O. Notez également qu'il s'agit d'une explication TRÈS simpliste. Big O est le plus commun, mais il est aussi plus complexe que je l’ai montré. Il existe également d'autres notations telles que gros oméga, petit o et grand thêta. Vous ne les rencontrerez probablement pas en dehors d'un cours d'analyse d'algorithme. ;)

Modifier:

Maintenant, la question est de savoir comment le log n est entré dans l'équation:

  1. Pour chaque étape, vous appelez l'algorithme de manière récursive sur la première et la seconde moitié.
  2. Ainsi, le nombre total d'étapes nécessaires correspond au nombre de fois qu'il faudra pour atteindre n à 1 si vous divisez le problème de 2 à chaque étape. 

L'équation est la suivante: n/2 ^ k = 1. Comme 2 ^ logn = n, on obtient k = logn. Donc, le nombre d'itérations requis par l'algorithme est O (logn), ce qui rend l'algorithme O(nlogn) 

De plus, la notation big O nous permet de calculer facilement une approximation indépendante de la plate-forme sur le comportement asymptotique de l’algorithme (à l’infini), ce qui permet de diviser la "famille" de l’algorithme en sous-ensembles de leur complexité, et comparer facilement entre eux.

Vous pouvez également consulter cette Question pour en savoir plus: Complexité temporelle du programme à l'aide de l'équation de récurrence

26
Vinayak Pahalwan

Vous devriez également lire à propos de Amortized Analysis pour bien comprendre les notions de complexité temporelle. L’analyse amortie permet d’avoir le pire des cas pour la performance d’un algorithme en considérant toutes les opérations.

Le lien vers l'article de Wikipedia est donné ci-dessous,

http://en.wikipedia.org/wiki/analysis_morties

1
Deepu