Complexité temporelle de l'algorithme Sieve of Eratosthenes

De Wikipedia:

La complexité de l'algorithme réside dans O(n(logn)(loglogn))les opérations sur les bits.

Comment y arrivez-vous?

Que la complexité inclut le loglognterme me dit qu'il y a un sqrt(n)quelque part.

Supposons que j'exécute le tamis sur les 100 premiers nombres ( n = 100), en supposant que le marquage des nombres comme composites prend un temps constant (implémentation du tableau), le nombre de fois que nous utilisons mark_composite()serait quelque chose comme

n/2 + n/3 + n/5 + n/7 + ... + n/97        =      O(n^2)                         

Et pour trouver le prochain nombre premier (par exemple pour sauter après 7avoir barré tous les nombres multiples de 5), le nombre d'opérations serait O(n).

Donc, la complexité serait O(n^3). Êtes-vous d'accord?

1. Votre n / 2 + n / 3 + n / 5 +… n / 97 n'est pas O (n), car le nombre de termes n'est pas constant. [Modifier après votre modification: O (n ² ) est une limite supérieure trop lâche.] Une limite supérieure lâche est n (1 + 1/2 + 1/3 + 1/4 + 1/5 + 1/6 +… 1 / n) (somme des réciproques de tous les nombres jusqu'à n), qui est O (n log n): voir nombre harmonique . Une borne supérieure plus correcte est n (1/2 + 1/3 + 1/5 + 1/7 +…), c'est-à-dire la somme des réciproques de nombres premiers jusqu'à n, qui est O (n log log n). (Voir ici ou ici .)

2. Le bit "trouver le prochain nombre premier" est seulement O (n) globalement, amorti - vous irez de l'avant pour trouver le nombre suivant seulement n fois au total , pas par pas. Donc, toute cette partie de l'algorithme ne prend que O (n).

Donc, en utilisant ces deux, vous obtenez une limite supérieure d'opérations arithmétiques O (n log log n) + O (n) = O (n log log n). Si vous comptez les opérations sur bits, puisque vous avez affaire à des nombres allant jusqu'à n, ils ont environ log n bits, c'est là que le facteur de log n entre en jeu, donnant O (n log n log log n) opérations sur bits.

Le fait que la complexité inclut le terme loglogn me dit qu'il y a un sqrt (n) quelque part.

Gardez à l'esprit que lorsque vous trouvez un nombre premier Ppendant le tamisage, vous ne commencez pas à rayer les nombres à votre position actuelle + P; vous commencez en fait à rayer des chiffres à P^2. Tous les multiples de Pmoins que P^2auront été barrés par les nombres premiers précédents.

1. La boucle interne fait des n/iétapes, où iest prime => toute la complexité est sum(n/i) = n * sum(1/i). Selon les séries harmoniques principales, sum (1/i)où iest premier est log (log n). Au total, O(n*log(log n)).

2. Je pense que la boucle supérieure peut être optimisée en la remplaçant npar sqrt(n)une complexité temporelle globale O(sqrt(n)loglog(n)):

   void isprime(int n)
   {
       int prime[n],i,j,count1=0;
       for(i=0;i<n;i++)
       {
          prime[i]=1;
       }
       prime[0]=prime[1]=0;
       for(i=2;i<=n;i++)
       {
           if(prime[i]==1)
           {
               printf("%d ",i);
               for(j=2;(i*j)<=n;j++)
                   prime[i*j]=0;
           }
       }    
   }
   

voir l'explication ci-dessus la boucle interne est la somme harmonique de tous les nombres premiers jusqu'à sqrt (n). Ainsi, la complexité réelle de est O (sqrt (n) * log (log (sqrt (n))))