线性筛法求素数的原理与实现
何为线性筛法，顾名思义，就是在线性时间内（也就是O（n））用筛选的方法把素数找出来的一种算法，没用过线性筛素数法的人可能会奇怪，用遍历取余判定素数不是也是线性时间的吗，没错，但是确切的说线性筛法并不是判定素数的，而是在线性时间内求出一个素数表，需要判定是否是素数的时候只要看该数是否在表内就可以瞬间知道是不是素数。
比如想求10000以内的素数，定义表int a[10000]，进行线性筛选后，a[n]的值就代表n是不是素数，a[n]如果是1，就代表n是素数，a[n]如果是0，就代表n不是素数，这就是查表。
再判定其他的素数也是一样，不用再做任何计算。
而如果用遍历取余，那么每判定一个数都要从头开始再遍历一遍，而线性筛法只在开始一次性运算完，以后只要查表即可，查表通常只需要1条语句。
所以如果你的程序从始至终只需要判定那么几次素数那么用遍历取余即可，但是如果需要多次判定素数，而且这个数还不是很小的话，那么线性筛法就会体现出巨大的优越性来。
线性筛法的核心原理就是一句话：每个合数必有一个最大因子（不包括它本身），用这个因子把合数筛掉，还有另一种说法（每个合数必有一个最小素因子，用这个因子筛掉合数，其实都一样，但是我觉得这种方法不太容易说明，这种方法我会在最后给出简略说明）。
这个很容易证明：这个小学就知道合数一定有因子，既然是几个数，就一定有最大的一个。
最大因子是唯一的，所以合数只会被它自己唯一的因子筛掉一次，把所有合数筛掉后剩下的就全是素数了。
先假设一个数i，一个合数t，i是t最大的因数，t显然可能并不唯一（例如30和45的最大因数都是15）。
那么如何通过i知道t呢，t必然等于i乘以一个比i小的素数。
先来说这个数为什么一定要比i小，这很显然，如果是i乘上一个比它大的素数，那么i显然不能是t
最大的因子。
再来说为什么要是素数，因为如果乘上一个合数，我们知道合数一定可以被分解成几个素数相乘的结果，如果乘上的这个合数x=p1*p2*……，那么
t = i * x = i * p1 * p2……很显然p1* i也是一个因数，而且大于i。
所以必须乘上一个素数。
比i小的素数一定有不少，那么该乘哪一个呢，既然t不唯一，那么是不是都乘一遍呢？很显然不行，虽然t不唯一，但全乘一遍很显然筛掉的数的数量远远超过合数的数量。
我们先给出结论：
任意一个数i = p1*p2*……*pn，p1、p2、……pn都是素数，p1是其中最小的素数，
设T 为i * M的积（显然T就成了一个合数），也就是T = i * M，（M是素数，并且M<=p1）,那么T的最大的因数就是i。
是的，乘上的数要小于等于i最小的质因数。
为什么呢？我来证明这一点。
假设i可以表示为素数乘积：i = p1*p2*...pn，其中i最小的素因数是p1，设M是素数，并且大于i最小的素因数p1。
设i*M=y，显然同时y=M * p1*p2*……pn因为M>p1，显然
M*p2*……pn要大于i=p1*p2*……pn，M*p2*……pn又很显然是y的一个因数，那么y的最大因数就不是i。
由此说明了了上面给出的结论。
本文给出的证明方法并不是很严格，很不严密，但是本文只是想解释线性筛素数的算法，并不是想严格证明，如果想看严格证明请看数论中的证明。
另上面提到的线性筛素数的另一种说法，其实到这里读者应该差不多明白了，任何一个合数都可分解为一个素数和另一个数（不一定是素数还是合数）的乘积。
我们既然找到了这个合数最大的因数，那么根据上面结论里另一个乘上的素数必然就是他的最小素因数。
另一种说法只不过是换一个说法罢了。
最后我们就可以得出结论：对于每一个数i，乘上小于等于i的最小素因数的素数，就得到以i为最大因数的合数。
设有一个数t，只要将所有以比t小的数为最大因数的合数筛去，那么比t小的数里剩下的就只有素数了。
这就是线性筛法求素数的方法。
用c++实现线性筛10000以内素数
[cpp]view plaincopy
1.//author： bjr
2.#define N 10000
3.int flag[N+1],prime[N+1],pnum;
4./*
5.flag[n] 表示n是否是素数，1是素数，0不是
6.prime 中是所有的素数按从小到大排列、
7.pnum 表示素数的个数
8.*/
9.void CreatePrime(){
10. pnum=0;//初始化没有素数
11.//先将所有数看做素数，然后开始筛选
12.for(int i=0; i<=N; i++){
13. flag[i]=1;
14. }
15.//遍历筛去所有最大因数是i的合数
16.for(int i=2; i<=N; i++){
17.if(flag[i]==1){
18.//把素数记录下来
19. p[pnum++]=i;
20. }
21.//遍历已知素数表中比i的最小素因数小的素数，并筛去合数
22.for(int j=0; j<pnum && p[j]*i<=N; j++){
23.//筛去合数
24. flag[p[j]*i]=0;
25.if(i%p[j]==0)
26.//找到i的最小素因数
27.break;
28. }
29. }。
实现素数筛法(C++)
实现素数筛法（C++）素数是指只能被1和自身整除的自然数。
素数筛法是一种用来找出一定范围内的所有素数的算法。
它的基本思想是从小到大逐个筛选，将合数标记为非素数，最后留下来的就是素数。
首先，我们需要一个布尔数组来表示每个数是否为素数。
数组的索引代表数本身，数组的值为true表示该数是素数，为false表示该数为合数。
我们将数组初始化为全部为素数（true）。
然后，我们从2开始，将2的倍数全部标记为合数（false）。
接下来，我们找到下一个未筛选的素数，即3。
将3的倍数全部标记为合数。
依此类推，我们将继续找到下一个未筛选的素数，并将其倍数全部标记为合数，直到达到指定范围的上限。
最后，留下来的所有素数的索引即为我们所要的答案。
我们可以使用一个循环来实现上述算法。
具体代码如下所示：```cpp#include <iostream>#include <vector>//素数筛法函数std::vector<int> primeSieve(int n) {std::vector<int> primes;std::vector<bool> isPrime(n + 1, true); //初始化全部为素数for (int p = 2; p * p <= n; p++) {if (isPrime[p]) {//将p的倍数全部标记为合数for (int i = p * p; i <= n; i += p) {isPrime[i] = false;}}}//收集所有素数for (int p = 2; p <= n; p++) {if (isPrime[p]) {primes.push_back(p);}}return primes;}int main() {int n;std::cout << "请输入要找出的范围上限n："; std::cin >> n;std::vector<int> primes = primeSieve(n);std::cout << "范围[2, " << n << "]内的所有素数为：" << std::endl;for (int prime : primes) {std::cout << prime << " ";}return 0;}```以上代码中，我们使用了`std::vector`数据结构来存储素数。
素数（超详细！！！）
素数（超详细）整数惟⼀分解定理素数筛法给定n，求出1~n之间所有的质数。
⼀、Eratosthenes筛法（☒此处本应有⼀幅动图，然鹅我并不知道该如何显⽰动图(｡-ω-)-ω-)-ω-)Eratosthenes筛法思想⼆、欧拉筛法（线性筛）埃⽒筛法中以n=30为例，30这个数被筛了3次，分别是：2*15(p=2)3*10(p=3)5*6(p=5)枚举 2~n 中的每⼀个数 i：如果 i 是素数则保存到素数表中;利⽤ i 和素数表中的素数 prime[j] 去筛除 i*prime[j] ，为了确保i*prime[j] 只被素数 prime[j] 筛除过这⼀次，要确保 prime[j] 是i*prime[j] 中最⼩的素还要⼩的素因⼦。
因⼦，即 i 中不能有⽐ prime[j] 还要⼩的素因⼦写法⼀：（仅⽤于判断）写法⼆：（可求出每个数的最⼩质因⼦）素数筛法优化素因数分解只要在判定素数时记录下每个数值的最⼩素因数即可。
⼀道肥肠简单的模板题——【例 1】Prime Distance（信息学奥赛⼀本通 1619）【题⽬描述】给定两个整数 L,R，求闭区间 [L,R] 中相邻两个质数差值最⼩的数对与差值最⼤的数对。
当存在多个时，输出靠前的素数对。
【输⼊】多组数据。
每⾏两个数 L,R。
【输出】详见输出样例。
【输⼊样例】2 1714 17【输出样例】2,3 are closest, 7,11 are most distant.There are no adjacent primes.。
欧拉函数求法与欧拉筛法求素数
欧拉函数求法与欧拉筛法求素数欧拉函数：欧拉函数定义：对于正整数n，欧拉函数Euler(n)是1到n-1中与n互质的数的个数，特别的，Euler(1) = 1，若n为质数则有 Euler(n) = n - 1欧拉函数的两种求法：1.由定义和常识可以知道对于任意⼀个素数n有 Euler(n) = n - 1，对于m = n ^ k，Euler(m)是⾮常好求解的，显然，只有n的倍数才是不满⾜欧拉函数的定义的数，只要减去即可。
得：Euler(m) = n ^ k - n ^ (k - 1)。
另外，附加介绍以⼀点关于简化剩余系的概念，取定m > 0，若r mod m 中的每个数都与m互素，则称r mod m是与m互素的剩余类。
从所有与模m互素的剩余类中各取⼀数所组成的⼀组数称为简化剩余系。
如 m = 5 有 1 mod 5, 2 mod 5, 3 mod 5, 4 mod 5，是与m互素的剩余类。
易知模m的⼀个简化剩余系中⼀共有Euler(m)个数，有定理：设(m1, m2) = 1,若x1，x2分别通过模m1，m2的⼀个简化剩余系，则m1x2 + m2x1通过m1m2的⼀个简化剩余系。
通过这个定理我们可以得到Euler(m * n) = Euler(m) * Euler(n)。
对于任意⼀个数，可以进⾏整数分解，分解成为 m = n1 ^ x1 * n2 ^ x2 * ni ^ xi，这样根据上⾯的两个结论我们可以得到Euler(m) = Euler(n1 ^ x1) * ... * Euler(ni ^ xi) = ((n1 ^ x1) - (n1 ^ (x1 - 1))) * ... * ((ni ^ xi) - ni ^ (xi - 1)) = (n1 - 1) * (n1 ^ (x1 - 1)) * ... * (ni - 1) * (ni ^ (xi - 1))，根据这个式⼦我们可以推出如下的性质：设n为m的质因数则有(m % n == 0) （1）若 (m / n) % n != 0 有E(m) = E(m / n) * (n - 1)，这⾥就是前⾯式⼦中每个质因数的前⾯的(ni - 1)。
P(xe,)筛法与素数分布定理
∴
为 p ( x e, ) 的台阶的尾数；
e1 f ( x e, ) = b ( xe, ) = b y = k e1 f ( x e, ) + 1 = b ( xe, ) + 1 = b k
+1
（2-7）
= ak +1
y +1 =
f ( xe, )
= f8 =
1 2 4 6 10 12 16 18 × × × × × × × 2 3 5 7 11 13 17 19
= 0.1710240
x f ( x e, )
（3） x f ( x e, ) = 346 × 0.1710240 = 59.17
∵ π ( x ) = π ( 346 ) =68, ∴ π ( x )
4 2 1 p −1 = 26 × × × = 6.93333 5 3 2 p p ≤ p ( xe ,, )
（6）第一个 X 区间的数字个数
n =7
除 1 以外全部为素数。显然 n＞m。
定义 5 保留素数 第一个 X 区间的数字个数中有一个数 1，不可能被筛去，因为 1 不是素 数，故将 1 筛去，这时第一个 X 区间的素数个数用 p x (1) 表示。把被筛去的素数保留下来， 将这些素数称保留素数，用 p x ( −1) 表示，显然第一个 X 区间的数字个数为：
2.1.2 台阶素数与台阶系数 令
p −1 ∏ = f ( x e, ) p ≤ p ( xe, ) p
（2-2）
定义 2 我们把 p ( x e, ) 称为台阶素数； p ( x e,−1) 为 p ( x e, ) 前面的一个素数； p ( x e,1) 为 p ( x e, ) 后面的一个素数。称 f ( xe, ) 为素数的台阶系数。简称台阶系数。显然，台阶系数 f ( x e, ) 具有 以下性质： （1） f ( x e, ) 是非负有界函数 （2） f ( x e, ) 是单调递减函数 （3） 当 x → ∞ 时
素数(质数)判断的五种方法
素数（质数）判断的五种方法素数判断是编写程序过程中常见的问题，所以今天我简单梳理一下常用的素数判断方法。
素数的介绍素数定义质数(prime number)又称素数，有无限个。
一个大于1的自然数，除了1和它本身外，不能被其他自然数整除，换句话说就是该数除了1和它本身以外不再有其他的因数;否则称为合数。
根据算术基本定理，每一个比1大的整数，要么本身是一个质数，要么可以写成一系列质数的乘积;而且如果不考虑这些质数在乘积中的顺序，那么写出来的形式是唯一的。
最小的质数是2。
--------360百科第一种：暴力筛选法思路分析根据素数的定义，我们可以简单地想到：若要判断n是不是素数，我们可以直接写一个循环（i从2到n-1，进行n%i运算，即n能不能被i整除，如被整除即不是素数。
若所有的i 都不能整除，n即为素数）。
代码实现booleanisPrime(int n){for(inti=2;i<n;i++){if(n%i==0){returnfalse;break;}}returntrue ;}时间复杂度：O(n)这个时间复杂度乍一看并不乐观，我们就简单优化一下。
booleanisPrime(int n){for( i=2; i<=(int)sqrt(n);i++){if(n%i==0){returnfalse;break;}}returntrue;}时间复杂度：O(sqrt(n))优化原理：素数是因子为1和本身，如果num不是素数，则还有其他因子，其中的因子，假如为a,b.其中必有一个大于sqrt(num) ，一个小于sqrt（num）。
所以必有一个小于或等于其平方根的因数，那么验证素数时就只需要验证到其平方根就可以了。
即一个合数一定含有小于它平方根的质因子。
第二种：素数表筛选法素数表的筛选方法一看就知道素数存储在一个表中，然后在表中查找要判断的数。
找到了就是质数，没找到就不是质数。
思路分析如果一个数不能整除比它小的任何素数，那么这个数就是素数对了，这个方法效率不高，看看就知道思路了。
素数的几种判断方法和实现
PS：本来没有决心把这个东西写完的，结果早上写到一半，出去吃个饭，没保存，回来手一抖直接关掉了，好不容易写了一大半了，只能重新写了，坑爹啊，但就是这个插曲，本来还没有决心的我，一下子却坚定了信念，一点要把这个东西写完。
就这样开始吧BY：Lee下面，我们重新开始═══════════════════════════════════════════如何判断一个数是否是素数呢═══════════════════════════════════════════也许你会认为这是一个简单的问题，但事实上，世界上任何一个问题，都没有你想象中的那么简单1 + 1 是否等于2 ，这便是一个简单而又复杂的问题，呵呵。
突然想把这个东西换一种风格来写了，就这样扯淡扯下去吧。
扯的时候文章中多少有内容来自于网络，没有侵权的意思，如果作者看到还请见谅。
═══════════════════════════════════════════下面正式进入正题═══════════════════════════════════════════一、朴素判断素数═══════════════════════════════════════════1. 这种方法被誉为笨蛋的做法：一个数去除以比它的一半还要大的数，一定除不尽的，这还用判断吗？？很容易发现的，这种方法判断素数，对于一个整数n，需要n-2 次判断，时间复杂度是O(n)在n非常大或者测试量很大的时候，这种笨蛋做法肯定是不可取的。
2. 改进一下下小学生的做法：3. 再改进一下聪明的小学生的做法对于一个小于n的整数X，如果n不能整除X,则n必定不能整除n/X。
反之相同一个明显的优化，就是只要从2枚举到√n 即可。
因为在判断2的同时也判断了n/2。
到√n时就把2到n-1都判断过了。
在这里，这个聪明的小学生还用了i*i <= n 来代替sqrt（n），这里是避免了调用函数sqrt（），其消耗时间很大，特别是在大量数据测试的时候消耗很明显。
例6、用筛法求出100以内的全部素数，并按每行五个数显示
例6、用筛法求出100以内的全部素数，并按每行五个数显示。
【问题分析】⑴把2到100的自然数放入a[2]到a[100]中（所放入的数与下标号相同）；⑵在数组元素中，以下标为序，按顺序找到未曾找过的最小素数minp,和它的位置p（即下标号）；⑶从p+1开始，把凡是能被minp整除的各元素值从a数组中划去（筛掉），也就是给该元素值置0；⑷让p=p+1，重复执行第②、③步骤，直到minp>Trunc(sqrt(N)) 为止；⑸打印输出a数组中留下来、未被筛掉的各元素值，并按每行五个数显示。
用筛法求素数的过程示意如下（图中用下划线作删去标志）：①2 3 4 5 6 7 8 9 10 11 12 13 14 15…98 99 100 ｛置数｝②2 3 4 5 6 7 8 9 10 11 12 13 14 15…98 99 100 {筛去被2整除的数}③2 3 4 5 6 7 8 9 10 11 12 13 14 15…98 99 100 {筛去被3整除的数}……2 3 4 5 6 7 8 9 10 11 12 13 14 15…98 99 100 {筛去被整除的数}Program Exam53;const N=100;type xx=1 .. N; {自定义子界类型xx（类型名）}V ar a: array[xx] of boolean; i,j: integer;BeginFillchar(a,sizeof(a),true);a[1] := False;for i:=2 to Trunc(sqrt(N)) doif a[I] thenfor j := 2 to N div I doa[I*j]:= False;t:=0;for i:=2 to N doif a[i] thenBeginwrite(a[ i ]:5); inc(t);if t mod 5=0 then writelnend;End.【例3】输入十个正整数，把这十个数按由大到小的顺序排列（将数据按一定顺序排列称为排序，排序的算法有很多，其中选择排序中的“简单选择排序”是一种较简单的方法）分析：要把十个数按从大到小顺序排列，则排完后，第一个数最大，第二个数次大，……；因此，我们第一步可将第一个数与其后的各个数依次比较，若发现，比它大的，则与之交换，比较结束后，则第一个数已是最大的数。
ACM 筛素数总结
【总结】关于求素数的说【两种筛法】（学习小结，请无视）素数大家都很熟了，不多说了，这里只想说一下求素数。
当然先是唯一素因子分解定理：合数a仅能以一种方式，写成如下的乘积形式：a=p1e1p2e2…prer其中pi为素数，p1<p2<…<pr，且ei为正整数对于一个整数n，当其在小于sqrt（n）范围里有一个约数，那么必然在大于sqrt（n)的范围里有对应的另一个Eratosthenes（埃拉托斯特尼筛法）都是到sqrt（n）的范围。
①。
试除法判素数对于大于1的正整数a，如果a具有小于或等于sqrt（a）的素因子，则a为合数，否则a为素数。
因此，可用区间[2,sqrt(a)]内的数去试除a，只要有一个数能整除a ，则a为合数，否则a为素数。
这种判断素复杂度O(sqrt(n)).IsPrime(a)for(i=2;i*i<=a;i++)if(a%i==0)return a为合数return a为素数②。
Sieve Of Eratosthenes（埃拉托斯特尼筛法）可以筛出2~n 范围里的所有素数。
1)将所有候选数2~n放入筛中;2)找出筛中最小数P，P一定为素数。
3)宣布P为素数，并将P的所有倍数从筛中筛去;4)重复2)至3)直到筛空.其实，当P>sqrt(n)时筛中剩下的数就已经都是素数了。
//用数组prime[MAXN]记录是否为素数；//prime[i]为0表示i为素数，否则为合数int prime[MAXN]={0};for(i=2;i*i<=n;i++){if(prime[i]==0){for(j=i+i;j<=n;j+=i)prime[j]=1;}}③。
线性筛法对于Sieve Of Eratosthenes，普通的筛法如果是一个合数，那么会被多次筛掉，比如6,当2作为素数时筛掉一线性筛法保证所有合数只被筛掉一次具体详见《ftfish利用积性函数的优化》，讲到了积性函数（对于正整数n的一个算术函数f(n)，当中f(1)=1且称它为积性函数。
用筛法求100以内的素数
1. 用筛法求100以内的素数。
算法：先将1~100放置于一个一维数组中，然后依次判断每个数是否素数，若不是素数将该元素置0，最后输出不为0的数。
如何判断一个数是否素数？素数定义是只能被1和本身整除的数，设置除数n=2~a[i]-1特殊的两个数1、2，不需要判断定义变量：int a[100]，i，n；输入数据：循环赋值，for(i=0;i<100;i++) a[i]=i+1;处理：双重循环，外层循环控制访问数组元素，内层循环控制除数的变化for(i=2;i<100;i++) for(n=2;n<=a[i]/2;n++) if(a[i]%n==0) a[i]=0；输出：for（i=0；i<100;i++）if(a[i]!=0) printf(“%3d”,a[i]);2. 编写一个程序，计算若干学生的某门功课的平均成绩、标准差，找出最高分和最低分。
算法：循环输入成绩，需要求和，然后求平均成绩；循环sqrt（求和（xi-aver）*（xi-aver））定义变量：float grade[N]，max，min，aver，bzc，sum；int i；输入数据：for(i=0;i<N;i++) scanf(“%f”,&grade[i]);处理：sum=0; max=min=grade[0];for(i=0;i<N;i++) {sum=sum+grade[i];if(max<grade[i]) max=grade[i]; if(min>grade[i]) min=grade[i];}aver=sum/N;sum=0; for(i=0;i<N;i++) sum=sum+(grade[i]-aver)* (grade[i]-aver);bzc=sqrt(sum/N);输出结果3.编写一个程序，让计算机产生20个随机数，用选择法排序。
98 36 54 18 65 23 48 78 84 8for(i=0;i<N-1;i++){p=i；for(j=i+1;j<N;j++) if(a[p]>a[j]) p=j;if(p!=i) { t=a[p];a[p]=a[i];a[i]=t;}}设置一个变量p，去记住最小值的下标，4. 根据上题的内容1，编一程序在数组中查找一个数。
素数筛法算法及其原理
素数筛法算法及其原理引⾔本⽂介绍部分素数筛法的步骤以及原理，并附带 python 算法的实现本⽂介绍的筛法有：厄拉多塞筛法（Eratosthenes Sieve ）Sundaram 筛法欧拉筛法（Euler Sieve ）分段筛法（Segmented Sieve ）增量筛（Incremental sieve ）Atkin 筛法厄拉多塞筛法（Sieve of Eratosthenes ）1. 厄拉多塞筛法步骤给定⼀个数 n，从 2 开始依次将 √n 以内的素数的倍数标记为合数标记完成后，剩余未被标记的数为素数（从 2 开始）算法原理如下：读取输⼊的数 n ，将 2 ⾄ n 所有整数记录在表中从 2 开始，划去表中所有 2 的倍数由⼩到⼤寻找表中下⼀个未被划去的整数，再划去表中所有该整数的倍数重复第(3)步，直到找到的整数⼤于 √n 为⽌表中所有未被划去的整数均为素数2. 厄拉多塞筛法原理⾸先，先证明这种⽅法能够标记所有 2~n 之间的合数。
由整数的唯⼀分解定理知，任意⼀个⼤于1的正整数都可以被分解成有限个素数的乘积。
因此，任意⼀个合数都可以看做是⼀个素数的倍数的形式。
对于任意⼀个合数 n ，存在 p, q ，使得 n = p·q （不妨设 p 为素数）同时可有 min(p, q) ≤ p ≤ √n ，否则会有 p · q ≥ min(p, q)2 ＞ n ，⽭盾故可知，任意合数都能被不⼤于 √n 的素数 p 标记其次，显然，该标记⽅法并不会错误地将素数标记成合数故该⽅法能且仅能标记所有 2~n 之间的合数，所以剩下未被标记的数就是素数（从 2 开始）3. 厄拉多塞筛法代码from math import sqrtdef sieve_of_eratosthenes(n: int):is_prime = [True for _ in range(n + 1)]for i in range(2, int(sqrt(n)) + 1):if is_prime[i]:for j in range(i * i, n + 1, i):is_prime[j] = False # 筛去j# 返回从2开始未被筛去的整数return [i for i in range(2, n + 1) if is_prime[i]]在筛去素数 p 倍数的过程中，我们是从 p 2 开始，⽽不是从 2·p 开始之前厄拉多塞筛法的原理中提到过，任意合数都能被不⼤于 √n 的素数标记。