查看“︁埃拉托斯特尼筛法”︁的源代码

{{NoteTA
|G1=Math
}}

'''埃拉托斯特尼筛法'''（{{lang-grc|κόσκινον Ἐρατοσθένους}}，{{lang-en|sieve of Eratosthenes}}），簡稱'''-{zh-cn:埃氏筛; zh-tw:埃氏篩; zh-hk:愛氏篩}-'''，是一种用來{{tsl|en|Generating primes|質數生成|生成}}[[質數]]的[[筛法]]，得名於[[古希臘數學|古希臘數學家]][[埃拉托斯特尼]]。其基本步骤是從最小的質數2開始，將该質數的所有倍數標記成[[合數]]，而下一个尚未被标记的最小自然数3即是下一个質數。如此重复这一过程，将各个质数的倍数标记为合数并找出下一个质数，最终便可找出一定範圍內所有質數。

埃拉托斯特尼筛法可能在埃拉托斯特尼的时代之前就已经为人所知<ref name="am">{{cite book |author1=Stefan Hougardy |author2=Jens Vygen |title=Algorithmic Mathematics |date=2016 |publisher=Springer International Publishing Switzerland |location=Cham |isbn=978-3-319-39558-6 |url=https://link.springer.com/book/10.1007/978-3-319-39558-6 |access-date=2024-01-05 |archive-date=2024-01-05 |archive-url=https://web.archive.org/web/20240105035111/https://link.springer.com/book/10.1007/978-3-319-39558-6 |dead-url=no }}</ref>{{rp|14}}，并记载于另一位古希腊数学家[[尼科马库斯]]的《{{tsl|en|Introduction to Arithmetic|算术概论}}》中，尽管该著作中的这一筛法是从3开始，从[[奇数]]中依次筛去奇数的倍数，而非从自然数中筛去质数的倍数<ref>{{cite book |author1=Jean-Luc Chabert |title=A History of Algorithms: From the Pebble to the Microchip |date=1999 |publisher=Springer-Verlag |location=Berlin, Heidelberg |isbn=978-3-642-18192-4 |url=https://link.springer.com/book/10.1007/978-3-642-18192-4 |access-date=2024-01-05 |archive-date=2024-01-05 |archive-url=https://web.archive.org/web/20240105035102/https://link.springer.com/book/10.1007/978-3-642-18192-4 |dead-url=no }}</ref>{{rp|242-243}}。

{{Image frame|width=350|content=[[File:Sieve_of_Eratosthenes_animation.gif|350px]]|align=right|caption=使用埃拉托斯特尼筛法找出120以内的所有質數。由于11{{sup|2}}=121>120，当11成为最小的未标记整数时，尚未标记的所有数皆可确认为質數。请注意到在标记时直接从每个质数的[[平方]]开始。}}

== 运用与示例 ==

埃拉托斯特尼筛法通过不断地标记当前质数的所有倍数为合数，从而取得最小的未标记整数为下一个質數。不过，在实际使用此筛法寻找一个范围内的質數时，不需要检查范围内所有整数，也不需要对每个質數都标记其所有的倍数。
#寻找<math>N</math>以内的質數时，若找到了一个大于<math>\sqrt{N}</math>的质数，则剩余的所有尚未标记的数也都是質數。
#:'''证明'''：若这些尚未标记的数中有任意一个为合数，设之为<math>m</math>，则<math>m</math>必定是除1与自身以外的两个[[因数]]的乘积。但既然<math>m</math>尚未被标记，则所有小于等于<math>\sqrt{N}</math>的数均不是<math>m</math>的因数。故这两个因数必然都大于<math>\sqrt{N}</math>，则<math>m</math>不可能在<math>N</math>以内<ref>{{cite book |author1=George M. Phillips |title=Mathematics Is Not a Spectator Sport |year=2005 |publisher=Springer-Verlag |location=New York |isbn=978-0-387-28697-6 |url=https://link.springer.com/book/10.1007/0-387-28697-7 |access-date=2024-01-05 |archive-date=2024-01-05 |archive-url=https://web.archive.org/web/20240105035106/https://link.springer.com/book/10.1007/0-387-28697-7 |dead-url=no }}</ref>{{rp|103-104}}<ref>{{cite book |author1=G. H. Hardy |authorlink1=戈弗雷·哈罗德·哈代 |author2=E. M. Wright |authorlink2=爱德华·梅特兰·赖特 |title=An Introduction to the Theory of Numbers (Fourth Edition) |url=https://archive.org/details/introductiontoth0000hard |date=1960 |publisher=Clarendon Press |location=Oxford |isbn=978-0-19-853310-8}}</ref>{{rp|4}}。
#标记某一質數<math>p</math>的倍数时，不需要每次皆从<math>2 p, 3 p, \ldots</math>开始，而可直接从<math>p^2</math>开始标记。
#:'''证明'''：所有较<math>p^2</math>更小的<math>p</math>的倍数必然拥有一个更小的质数为其因数，故在标记之前的质数的倍数时它们已经被标记过了<ref name="tgse">{{cite journal |author1=Melissa E. O'Neill |title=The Genuine Sieve of Eratosthenes |journal=Journal of Functional Programming |date=2009 |volume=19 |issue=1 |pages=95-106 |doi=10.1017/S0956796808007004 |url=https://www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf |access-date=2024-01-05 |archive-date=2024-07-26 |archive-url=https://web.archive.org/web/20240726075132/https://www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf |dead-url=no }}</ref>。

若要找出25以内的所有质数，使用如上述改进过的埃拉托斯特尼筛法的具体过程如下：

#列出2以後所有數：
#:2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
#记录質数2，由2{{sup|2}}=4开始划去2的倍数：
#:<span style="font-size:x-large;">2</span> 3 {{gray|<s> 4 </s>}} 5 {{gray|<s> 6 </s>}} 7 {{gray|<s> 8 </s>}} 9 {{gray|<s>10</s>}} 11 {{gray|<s>12</s>}} 13 {{gray|<s>14</s>}} 15 {{gray|<s>16</s>}} 17 {{gray|<s>18</s>}} 19 {{gray|<s>20</s>}} 21 {{gray|<s>22</s>}} 23 {{gray|<s>24</s>}} 25
#记录下一質数3，由3{{sup|2}}=9开始划去3的倍数：
#:<span style="font-size:x-large;">2</span> <span style="font-size:x-large;">3</span> {{gray|<s> 4 </s>}} 5 {{gray|<s> 6 </s>}} 7 {{gray|<s> 8 </s>}}{{gray|<s> 9 </s>}}{{gray|<s>10</s>}} 11 {{gray|<s>12</s>}} 13 {{gray|<s>14 </s>}}{{gray|<s>15 </s>}}{{gray|<s>16</s>}} 17 {{gray|<s>18</s>}} 19 {{gray|<s>20 </s>}}{{gray|<s>21 </s>}}{{gray|<s>22</s>}} 23 {{gray|<s>24</s>}} 25
#记录下一質数5，由5{{sup|2}}=25开始划去5的倍数：
#:<span style="font-size:x-large;">2</span> <span style="font-size:x-large;">3</span> {{gray|<s> 4 </s>}} <span style="font-size:x-large;">5</span> {{gray|<s> 6 </s>}} 7 {{gray|<s> 8 </s>}}{{gray|<s> 9 </s>}}{{gray|<s>10</s>}} 11 {{gray|<s>12</s>}} 13 {{gray|<s>14 </s>}}{{gray|<s>15 </s>}}{{gray|<s>16</s>}} 17 {{gray|<s>18</s>}} 19 {{gray|<s>20 </s>}}{{gray|<s>21 </s>}}{{gray|<s>22</s>}} 23 {{gray|<s>24</s>}} {{gray|<s> 25 </s>}}
#下一質数为7，而7{{sup|2}}=49>25，故剩余所有未标记的数皆为質数：
#:<span style="font-size:x-large;">2</span> <span style="font-size:x-large;">3</span> {{gray|<s> 4 </s>}} <span style="font-size:x-large;">5</span> {{gray|<s> 6 </s>}} <span style="font-size:x-large;">7</span> {{gray|<s> 8 </s>}}{{gray|<s> 9 </s>}}{{gray|<s>10</s>}} <span style="font-size:x-large;">11</span> {{gray|<s>12</s>}} <span style="font-size:x-large;">13</span> {{gray|<s>14 </s>}}{{gray|<s>15 </s>}}{{gray|<s>16</s>}} <span style="font-size:x-large;">17</span> {{gray|<s>18</s>}} <span style="font-size:x-large;">19</span> {{gray|<s>20 </s>}}{{gray|<s>21 </s>}}{{gray|<s>22</s>}} <span style="font-size:x-large;">23</span> {{gray|<s>24</s>}} {{gray|<s> 25 </s>}}

由此得到25內的質数为2，3，5，7，11，13，17，19，23。

以上的算法可用以下[[伪代码|-{zh-cn:伪代码;zh-tw:虛擬碼;}-]]表示：

-{zh-cn:
 '''输入'''：整数''n'' > 1
 &nbsp;<!-- these &nbsp; prevent bots messing it up -->
 设''A''为布尔值矩阵，下标是2至''n''的整数，
 初始时全部设成'''true'''。
 &nbsp;
  '''for''' ''i'' = 2, 3, 4, ..., 不超过{{根號|n|use math=yes}}：
   '''if''' ''A''[''i'']为'''true'''：
     '''for''' ''j'' = ''i<sup>2</sup>'', ''i<sup>2</sup>+i'', ''i<sup>2</sup>+2i'', ''i<sup>2</sup>+3i'', ..., 不超过''n''：
       ''A''[''j''] := '''false'''
 &nbsp;
 '''输出'''：使''A''[''i'']为'''true'''的所有''i''。;zh-tw:

 '''輸入'''：整數''n'' > 1
 &nbsp;<!-- these &nbsp; prevent bots messing it up -->
 設''A''為布爾值陣列，指標是2至''n''的整數，
 初始時全部設成'''true'''。
 &nbsp;
  '''for''' ''i'' = 2, 3, 4, ..., 不超過{{根號|n|use math=yes}}：
   '''if''' ''A''[''i'']為'''true'''：
     '''for''' ''j'' = ''i<sup>2</sup>'', ''i<sup>2</sup>+i'', ''i<sup>2</sup>+2i'', ''i<sup>2</sup>+3i'', ..., 不超過''n''：
       ''A''[''j''] := '''false'''
 &nbsp;
 '''輸出'''：使''A''[''i'']為'''true'''的所有''i''。;}-

埃拉托斯特尼筛法的[[时间复杂度]]为<math>O(n\log (\log n))</math>；相比之下，若是通过对范围内每个整数进行[[试除法]]来找出范围内的质数，则其时间复杂度为<math>O(n\sqrt {n})</math><ref name="am" />{{rp|13-14}}<ref name="tgse" />。

==程式码==
===Python 3.6-3.10===
<syntaxhighlight lang="python" line="1">
def eratosthenes(n):
    is_prime = [True] * (n + 1)
    for i in range(2, int(n ** 0.5) + 1):
        if is_prime[i]:
            for j in range(i * i, n + 1, i):
                is_prime[j] = False
    return [x for x in range(2, n + 1) if is_prime[x]]
print(eratosthenes(120))
</syntaxhighlight>

===C語言===
<syntaxhighlight lang="c" line="1">
int prime[100005];
bool is_prime[1000005];

int eratosthenes(int n) {
    int p = 0;
    for (int i = 0; i <= n; i++) {
        is_prime[i] = true;
    }
    is_prime[0] = is_prime[1] = 0;
    for (int i = 2; i <= n; i++) {
        if (is_prime[i]) {
            prime[p++] = i;
            if (1ll * i * i <= n) {
                for (int j = i * i; j <= n; j += i) {
                    is_prime[j] = 0;
                }
            }
        }
    }
    return p;
}
</syntaxhighlight>

C語言新版
<syntaxhighlight lang="c" line="1">
#include <stdio.h>
#include <stdlib.h>

/* N: positive integer
   verbose: 1 -- print all prime numbers < N, 0 -- no print
   return total number of prime numbers < N. 
   return -1 when there is not enough memory.
*/
int eratosthenesSieve(unsigned long long int N, int verbose) {
  // prime numbers are positive, better to use largest unsiged integer
  unsigned long long int i, j, total; // total: number of prime numbers < N
  _Bool *a = malloc(sizeof(_Bool) * N);

  if (a == NULL) {
    printf("No enough memory.\n");
    return -1;
  }
  
  /* a[i] equals 1: i is prime number.
     a[i] equals 0: i is not prime number.
     From beginning, set i as prime number. Later filter out non-prime numbers
  */
  for (i = 2; i < N; i++) {
    a[i] = 1; 
  }

  // mark multiples(<N) of i as non-prime numbers
  for (i = 2; i < N; i++) {
    if (a[i]) { // a[i] is prime number at this point
      for (j = i; j < (N / i) + 1; j++) {
	/* mark all multiple of 2 * 2, 2 * 3, as non-prime numbers;
	   do the same for 3,4,5,... 2*3 is filter out when i is 2
	   so when i is 3, we only start at 3 * 3
	*/
	a[i * j] = 0;
      }
    }
  }

  // count total. print prime numbers < N if needed.
  total = 0;
  for (i = 2; i < N; i++) {
    if (a[i]) { // i is prime number
      if (verbose) {
	printf("%llu\n", i);
      }
      total += 1;
    }
  }

  return total;
}

int main() {
  unsigned long long int a1 = 0, a2 = 0, N = 10000000;
  
  a1 = eratosthenesSieve(N, 1); // print the prime numbers
  printf("Total of prime numbers less than %llu is : %llu\n", N, a1);
  
  a2 = eratosthenesSieve(N, 0); // not print the prime numbers
  printf("Total of prime numbers less than %llu is : %llu\n", N, a2);
  
  return 0;
}
</syntaxhighlight>

===C++===
<syntaxhighlight lang="c++" line="1">
#include <vector>

auto eratosthenes(int upperbound) {
  std::vector<bool> flag(upperbound + 1, true);
  flag[0] = flag[1] = false; //exclude 0 and 1
  for (int i = 2; i * i <= upperbound; ++i) {
    if (flag[i]) {
      for (int j = i * i; j <= upperbound; j += i)
        flag[j] = false;
    }
  }	
  return flag;
}
</syntaxhighlight>

===R===
<syntaxhighlight lang="r" line="1">
eratosthenes <- function(n) {
  if (n == 1) return(NULL)
  if (n == 2 | n == 3) return(2:n)
  numbers <- 2:n
  primes <- rep(TRUE, n-1)
  for (i in 2:floor(sqrt(n))) {
    if (primes[i-1]) {
      for (j in seq(i * i, n, i))
        primes[j-1] <- FALSE
    }
  }
  return(numbers[primes])
}
</syntaxhighlight>

===JavaScript===
<syntaxhighlight lang="js" line="1">
const countPrimes = function (n) {
  const isPrime = new Array(n).fill(true);

  for (let i = 2; i <= Math.sqrt(n); i++) {
    if (isPrime[i]) {
      for (let j = i * i; j <= n; j += i) {
        isPrime[j] = false;
      }
    }
  }

  let count = 0;
  for (let i = 2; i < n; i++) {
    if (isPrime[i]) {
      count++;
    }
  }

  return count;
};

</syntaxhighlight>

==参见==
{{div col|cols=2}}
*[[篩法]]
*[[卢卡斯-莱默检验法]]
*[[米勒-拉宾检验]]
*[[试除法]]
*[[费马素性检验]]
*[[孪生素数]]
*[[三胞胎素数]]
*[[四胞胎素数]]
*[[素数判定法则]]
*[[表兄弟素数]]
*[[六素数]]
*[[X²+1素数]]
*[[勒讓德篩法]]
*{{link-en|普理查篩法|Sieve of Pritchard}}
*{{link-en|阿特金篩法|Sieve of Atkin}}
*{{link-en|孫達蘭篩法|Sieve of Sundaram}}{{div col end}}

==参考文献==
<references />

== 拓展阅读 ==
*[http://www.faust.fr.bw.schule.de/mhb/eratosiv.htm Interactive animation (需要JavaScript)] {{Wayback|url=http://www.faust.fr.bw.schule.de/mhb/eratosiv.htm |date=20070208053720 }}
*[https://coolshell.cn/articles/3738.html 打印质数的各种算法] {{Wayback|url=https://coolshell.cn/articles/3738.html |date=20201105040010 }}
*[https://web.archive.org/web/20180220153640/http://debug18.com/posts/introduction-to-sieve-method/ 筛法小结 (Eratosthenes/Euler)]
*[http://blog.csdn.net/lytning/article/details/24432651 欧拉函数线性筛法详解] {{Wayback|url=http://blog.csdn.net/lytning/article/details/24432651 |date=20200607193845 }}（欧拉函数线性筛）
*[http://blog.csdn.net/dinosoft/article/details/5829550 一般筛法求素数+快速线性筛法求素数(较好理解)] {{Wayback|url=http://blog.csdn.net/dinosoft/article/details/5829550 |date=20200607193849 }}

{{数论算法}}

[[Category:素性测试]]
[[Category:带有伪代码示例的条目]]
[[Category:筛法| ]]
[[Category:算法]]