Aperçu
D'autres ont donné de bons exemples de diagrammes, tels que les diagrammes d'arbre. Je n'ai vu aucun exemple de code simple. Donc, en plus de mon explication, je fournirai quelques algorithmes avec des instructions d'impression simples pour illustrer la complexité des différentes catégories d'algorithmes.
Tout d'abord, vous voudrez avoir une idée générale du logarithme, que vous pouvez obtenir sur https://en.wikipedia.org/wiki/Logarithm . Utilisation des sciences naturelles eet logarithme naturel. Les disciples du génie utiliseront log_10 (base de journal 10) et les informaticiens utiliseront beaucoup log_2 (base de journal 2), car les ordinateurs sont basés sur le binaire. Parfois, vous verrez des abréviations de log naturel comme ln(), les ingénieurs laissent normalement le _10 éteint et utilisent simplement log()et log_2 est abrégé en lg(). Tous les types de logarithmes se développent de manière similaire, c'est pourquoi ils partagent la même catégorie de log(n).
Lorsque vous regardez les exemples de code ci-dessous, je recommande de regarder O (1), puis O (n), puis O (n ^ 2). Une fois que vous êtes bon avec ceux-ci, regardez les autres. J'ai inclus des exemples clairs ainsi que des variations pour montrer comment des changements subtils peuvent toujours entraîner la même catégorisation.
Vous pouvez considérer O (1), O (n), O (logn), etc. comme des classes ou des catégories de croissance. Certaines catégories prendront plus de temps que d'autres. Ces catégories nous permettent de classer les performances de l'algorithme. Certains se sont développés plus rapidement à mesure que l'entrée n augmente. Le tableau suivant montre numériquement cette croissance. Dans le tableau ci-dessous, considérez log (n) comme le plafond de log_2.
Exemples de codes simples de diverses catégories Big O:
O (1) - Exemples à temps constant:
L'algorithme 1 s'imprime bonjour une fois et ne dépend pas de n, il s'exécutera donc toujours en temps constant O(1).
print "hello";
L'algorithme 2 s'imprime bonjour 3 fois, mais il ne dépend pas d'une taille d'entrée. Même à mesure que n grandit, cet algorithme n'imprimera toujours bonjour que 3 fois. Cela étant dit 3, est une constante, donc cet algorithme l'est aussi O(1).
print "hello";
print "hello";
print "hello";
O (log (n)) - Exemples logarithmiques:
- Algorithme 3 - Cela agit comme "log_2"
L'algorithme 3 illustre un algorithme qui s'exécute dans log_2 (n). Remarquez la post-opération de la boucle for multiple la valeur actuelle de i par 2, donc iva de 1 à 2 à 4 à 8 à 16 à 32 ...
for(int i = 1; i <= n; i = i * 2)
print "hello";
- Algorithme 4 - Cela agit comme "log_3"
L'algorithme 4 illustre log_3. L'avis iva de 1 à 3 à 9 à 27 ...
for(int i = 1; i <= n; i = i * 3)
print "hello";
- Algorithme 5 - Cela agit comme "log_1.02"
L'algorithme 5 est important, car il permet de montrer que tant que le nombre est supérieur à 1 et que le résultat est multiplié à plusieurs reprises contre lui-même, vous regardez un algorithme logarithmique.
for(double i = 1; i < n; i = i * 1.02)
print "hello";
O (n) - Exemples de temps linéaire:
Cet algorithme est simple, qui s'imprime bonjour n fois.
for(int i = 0; i < n; i++)
print "hello";
Cet algorithme montre une variation, où il s'imprimera bonjour n / 2 fois. n / 2 = 1/2 * n. Nous ignorons la constante 1/2 et voyons que cet algorithme est O (n).
for(int i = 0; i < n; i = i + 2)
print "hello";
O (n * log (n)) - nlog (n) Exemples:
Considérez cela comme une combinaison de O(log(n))et O(n). L'imbrication des boucles for nous aide à obtenir leO(n*log(n))
for(int i = 0; i < n; i++)
for(int j = 1; j < n; j = j * 2)
print "hello";
L'algorithme 9 est comme l'algorithme 8, mais chacune des boucles a permis des variations, ce qui a pour résultat que le résultat final est O(n*log(n))
for(int i = 0; i < n; i = i + 2)
for(int j = 1; j < n; j = j * 3)
print "hello";
O (n ^ 2) - n au carré Exemples:
O(n^2) s'obtient facilement en imbriquant un standard pour les boucles.
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
print "hello";
Comme l'algorithme 10, mais avec quelques variantes.
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j = j + 2)
print "hello";
O (n ^ 3) - n cubes Exemples:
C'est comme l'algorithme 10, mais avec 3 boucles au lieu de 2.
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
for(int k = 0; k < n; k++)
print "hello";
Comme l'algorithme 12, mais avec quelques variations qui donnent toujours O(n^3).
for(int i = 0; i < n; i++)
for(int j = 0; j < n + 5; j = j + 2)
for(int k = 0; k < n; k = k + 3)
print "hello";
Sommaire
Ce qui précède donne plusieurs exemples simples et des variations pour aider à démontrer quels changements subtils peuvent être introduits qui ne changent vraiment pas l'analyse. J'espère que cela vous donnera suffisamment d'informations.
