Big O pour (n log n)
J'étudie actuellement des algorithmes de base pour Big Oh. Je me demandais si quelqu'un pouvait me montrer ce que le code pour (n log n) dans Java en utilisant Big Oh serait comme ou me diriger vers une SO page où l'on existe.
Comme je ne suis qu'un débutant, je ne peux qu'imaginer le code avant de l'écrire. Donc, théoriquement (au moins), il devrait en contenir un pour la boucle où nous avons quelque chose de n fois. Ensuite, pour le log n, nous pouvons utiliser la boucle while. Ainsi, la boucle est exécutée n fois et la boucle while est exécutée 2 fois sur la base du journal. C'est du moins ainsi que je l'imagine dans ma tête, mais voir le code clarifierait les choses.
int n = 100
for(int i = 0; i < n; i++) //this loop is executed n times, so O(n)
{
for(int j = n; j > 0; j/=2) //this loop is executed O(log n) times
{
}
}
Explication: la boucle for externe doit être claire; il est exécuté n fois. Passons maintenant à la boucle intérieure. Dans la boucle interne, vous prenez n et vous le divisez toujours par 2. Alors, vous vous demandez: combien de fois puis-je diviser n par 2?
Il s'avère que c'est O (log n). En fait, la base de log est 2, Mais en notation Big-O, nous supprimons la base car elle n'ajoute à notre log que des facteurs qui ne nous intéressent pas .
Ainsi, vous exécutez une boucle n fois, et dans cette boucle, vous exécutez une autre boucle log(n) fois. Donc, vous avez O(n) * O(log n) = O(n log n).
Un algorithme O (n log n) très populaire est le tri par fusion. http://en.wikipedia.org/wiki/Merge_sort par exemple de l'algorithme et du pseudocode. La partie log n de l'algorithme est obtenue en décomposant le problème en sous-problèmes plus petits, dans lesquels la hauteur de l'arbre de récursivité est log n.
Beaucoup d'algorithmes de tri ont le temps d'exécution de O (n log n). Reportez-vous à http://en.wikipedia.org/wiki/Sorting_algorithm pour plus d'exemples.
Les algorithmes avec une complexité temporelle O(.) impliquant log n Impliquent généralement une certaine forme de division et de conquête.
Par exemple, dans MergeSort la liste est divisée par deux, chaque partie est triée par fusion individuellement puis les deux moitiés sont fusionnées. Chaque liste est divisée par deux .
Chaque fois que vous avez un travail divisé par deux ou réduit en taille par un facteur fixe, vous vous retrouverez généralement avec un composant log n De la O(.).
En termes de code, jetez un œil à l'algorithme pour MergeSort. La caractéristique importante, des implémentations typiques, est qu'elle est récursive (notez que TopDownSplitMerge s'appelle deux fois dans le code donné sur Wikipedia).
Tous les bons algorithmes de tri standard ont O(n log n) complexité temporelle et il n'est pas possible de faire mieux dans le pire des cas, voir Comparison Sort .
Pour voir à quoi cela ressemble dans Java, juste recherche ! Voici un exemple .
http://en.wikipedia.org/wiki/Heapsort
Un exemple simple est comme vous l'avez décrit - exécutez n fois une opération qui prend du temps log (n). Les arbres binaires équilibrés ont une hauteur log (n), donc certains algorithmes d'arbre auront une telle complexité.