La deuxième boucle passe de I à I ^ 2 -1 Donc non. de fois = i ^ 2 - i + 1 p>
xxx pré> Exploitation extérieure N Times P> blockQuote>
xxx pré> Ceci exécute J fois p> blockQuote>
xxx pré> blockquote>
3 Réponses :
Vous trouverez votre réponse ici j est en cours d'exécution sur i ^ 2 (ou i * i), ce qui donne lieu à O (i ^ 2) pour la boucle interne p > p>
Le point de départ peut être ignoré quand je deviens plus gros, tout comme un exemple, je prends i = 100 ... JJ Jour de 100 à 100 000, ce qui signifie 99,900 itérations qui sont presque à i * i.
Donc non. de fois = i ^ 2 - i + 1 p> blockQuote>
si
i code> devient plus grand fort>, par exemple extrêmement volumineux, alors
i ^ 2 code> amd
i code> est tous deux devenir extrêmement grand. Cependant,
i ^ 2 code> augmente plus vite em> que
i code>, puis l'augmentation de
i code> peut être ignorée em> comparée à l'augmentation de
i ^ 2 code>. Pour le Big-O notation de Complexité de temps , ceci est exprimé comme
O (i ^ 2) fort>. p>. En plus, c'est "O" (lettre O), pas "0" (numéro zéro). P>
Qu'est-ce que vous dites, c'est que parce que la boucle interne va de I à I², la complexité ne doit pas être O (I²). Chaque fois que vous multipliez I par un numéro N (10 dans mon cas), la boucle interne fonctionnera pour plus de N² plus de fois.
Qui montre que la complexité est Conclusion: la complexité est La plupart du code que vous verrez jamais a une complexité de la liste ordonnée ci-dessous, ou une combinaison d'entre eux (plus à ce sujet plus tard): La complexité est un terme qui ne s'applique que pour des nombres très gros. Dans votre cas, avec une très grande valeur, Plus généralement, la complexité ne se multiplie que: p>
Évidemment, lorsque vous combinez des complexités, la commande restera inchangée. Comme vous pouvez le constater, grâce aux valeurs entre N et N ^ 2 dans ma liste précédente. P>
La complexité est en effet
n ^ 0 (= constante)
Il n'est pas pertinent pour de petites valeurs, comme vous le verrez ici par exemple. p>
i² code> est écrasant devant
i code> donc
o (i²-i) = O (i²) < / code>. p>
o (n) code> li>
O (n ^ 2) code> li>
O (n ^ 3) code> li>
ul>
Par exemple, ma liste ordonnée avant, multipliée par O (n) code> deviendra:
n