web-dev-qa-db-fra.com

La complexité est-elle O(log(n)) équivalente à O (sqrt (n))?

Mon professeur vient de nous apprendre que toute opération qui divise par deux la longueur de l'entrée présente une complexité O(log(n)) comme règle du pouce. Pourquoi n'est-ce pas O (sqrt (n)), les deux ne sont-ils pas équivalents?

algorithmtime-complexity
27
white_tree

Ils ne sont pas équivalents: sqrt (N) augmentera beaucoup plus que log2(N). Il n'y a pas de constante C pour que vous ayez sqrt (N) <C.log (N) pour toutes les valeurs de - N supérieur à une valeur minimale.

Un moyen facile de saisir ceci, est que log2(N) sera une valeur proche du nombre de chiffres (binaires) de N , tandis que sqrt (N) = sera un nombre qui a lui-même la moitié du nombre de chiffres que N . Ou, pour déclarer cela avec une égalité:

bûche2(N 2log2(sqrt (N))) ==

Il faut donc prendre le logarithme (!) De sqrt (N) pour le ramener au même ordre de complexité que log2(N).

Par exemple, pour un nombre binaire de 11 chiffres, 0b10000000000 (= 2dix), la racine carrée est 0b100000, mais le logarithme n’est que 10.

42
trincot

En supposant que natural logarithm (Sinon multipliez simplement par une constante), nous avons

lim {n->inf} log n / sqrt(n) = (inf / inf)

                        =  lim {n->inf} 1/n / 1/(2*sqrt(n)) (by L'Hospital)
                        =  lim {n->inf} 2*sqrt(n)/n
                        =  lim {n->inf} 2/sqrt(n)
                        =  0 < inf

Reportez-vous à https://en.wikipedia.org/wiki/Big_O_notation pour la définition alternative de O(.) et, de ce fait, par le haut, nous pouvons dire log n = O(sqrt(n)),

Comparez également la croissance des fonctions ci-dessous, log n Est toujours délimité par le haut de sqrt(n) pour les grands n.

enter image description here

10
Sandipan Dey

Non, ce n'est pas équivalent.

@trincot a donné une excellente explication avec un exemple dans sa réponse. J'ajoute un autre point. Votre professeur vous a appris que

any operation that halves the length of the input has an O(log(n)) complexity

C'est aussi vrai que,

any operation that reduces the length of the input by 2/3rd, has a O(log3(n)) complexity
any operation that reduces the length of the input by 3/4th, has a O(log4(n)) complexity
any operation that reduces the length of the input by 4/5th, has a O(log5(n)) complexity
So on ...

C'est même vrai pour toute réduction de longueur de l'entrée de (B-1)/Bth. Il a alors une complexité de O(logB(n))

N:B:O(logB(n)) signifie B logarithme basé sur n

3
jbsu32

Non, ils ne sont pas équivalents; vous pouvez même le prouver

   O(n**k) > O(log(n, base))

pour tout k > 0 et base > 1 (k = 1/2 dans le cas de sqrt).

Lorsque nous parlons sur O(f(n)), nous souhaitons étudier le comportement de large n, limites est un bon moyen pour cela. Supposons que les deux gros O soient équivalents:

  O(n**k) = O(log(n, base))

ce qui signifie qu'il y a une certaine constante finie C telle que

  O(n**k) <= C * O(log(n, base))

à partir de quelque chose d'assez gros n; mettez-le en d'autres termes (log(n, base) n'est pas 0 à partir d'un grand n, les deux fonctions sont continuellement différentiables):

  lim(n**k/log(n, base)) = C 
  n->+inf

Pour connaître la valeur de la limite, nous pouvons utiliser règle de L'Hospital , c'est-à-dire prendre des dérivées pour le numérateur et le dénominateur et les diviser:

  lim(n**k/log(n)) = 

  lim([k*n**(k-1)]/[ln(base)/n]) =

  ln(base) * k * lim(n**k) = +infinity

nous pouvons donc en conclure qu'il n'y a pas de constante C telle que O(n**k) < C*log(n, base) ou autrement dit

 O(n**k) > O(log(n, base))
2
Dmitry Bychenko

Non ce n'est pas. Lorsque nous traitons avec la complexité du temps, nous pensons que l'entrée est un très grand nombre. Alors prenons n = 2 ^ 18. Maintenant pour sqrt (n) le nombre d'opération sera 2 ^ 9 et pour log (n) il sera égal à 18 (nous considérons log avec la base 2 ici). Il est clair que 2 ^ 9 est beaucoup plus grand que 18. On peut donc dire que O (log n) est plus petit que O (sqrt n).

1
androidGeek