素数的几种判断方法和实现
素数判断如何判断一个数是否为素数
素数判断如何判断一个数是否为素数素数是指除了1和本身之外没有其他因数的自然数。
在数论中，素数因其独特的性质和重要性而备受关注。
判断一个数是否为素数是数学中的一个基本问题，下面将介绍几种常用的方法来判断一个数是否为素数。
一、试除法试除法是一种简单直接的判断素数的方法。
对于一个待判断的数n，如果n能被不大于根号n的自然数整除，则n不是素数；如果n不能被不大于根号n的自然数整除，则n是素数。
二、埃拉托斯特尼筛法埃拉托斯特尼筛法是一种高效的筛选素数的方法。
基本思想是从2开始，依次找到每一个素数，然后将能被该素数整除的数标记为非素数。
具体操作为，将2到N的自然数按顺序排列，对于每个素数p，将大于p且能被p整除的数标记为非素数。
遍历完所有素数后，剩下的未被标记的数即为素数。
三、费马小定理费马小定理是一种通过取模运算判断素数的方法。
若p为素数，a是小于p的任意整数，则a的p次幂与a模p的余数相等。
即a^p ≡ a (mod p)。
基于这个定理，可以用快速幂算法来计算a^p的结果，如果与a模p的余数相等，则a为素数。
四、Miller-Rabin素性测试Miller-Rabin素性测试是一种概率算法，用于测试一个数是否为素数。
该算法基于费马小定理的倒推，通过多次的概率测试来判断一个数的素性。
算法的具体原理较为复杂，在此不做详细介绍。
综上所述，判断一个数是否为素数可以使用试除法、埃拉托斯特尼筛法、费马小定理或Miller-Rabin素性测试等方法。
根据具体需求和时间复杂度要求选择合适的算法来判断素数。
求素数的算法
求素数的算法
1. 定义
素数又称质数，是指只能被1和它本身整除的自然数，如2、3、5、7、11等，而4、6、8、9等都不是素数。
2. 筛法
筛法是一种较为简单的求素数的算法，主要原理是先假设所有数都是素数，然后从小
到大开始筛选，将所有能够整除当前数字的数标记为合数，剩余的就是素数。
具体步骤如下：
（1）初始化数组：将从2到n的所有整数存入数组中，初始时都标记为素数。
（2）循环遍历数组：从2开始循环遍历数组，将当前数字标记为素数，然后将所有能够整除当前数字的数标记为合数。
（实际上只需要循环到sqrt(n)即可）
（3）输出素数：遍历数组，输出所有标记为素数的数。
3. 质数判定法
如果只需要判断某一个给定的数是否是素数，那么可以采用质数判定法。
常见的质数
判定法有以下几种：
（1）试除法：从2开始到sqrt(n)依次尝试除n，如果能够整除则不是素数，否则是
素数。
这种方法速度较慢，但实现简单。
（2）根号判定法：如果一个数n不是素数，那么n可以表示为两个整数的乘积，即n = x * y。
这两个整数必然有至少一个小于等于sqrt(n)。
因此，只需要判断是否存在小于等于sqrt(n)的因数即可。
（3）费马小定理：如果n是素数，那么对于任意整数a，a^(n-1) mod n = 1。
根据这个定理，我们可以随机选取一些a进行计算，如果a^(n-1) mod n 不等于 1，则n一定不是素数，否则n可能是素数。
（4）米勒-拉宾素性判定法：该方法是一种基于费马小定理的扩展算法。
具体实现过
程较为复杂，但速度较快，能够判断很大的素数。
判断素数的四种方法
判断素数的四种⽅法傻⽠⽅法思路：按照素数的定义，除了1和它本⾝没有其他的因数，就是素数。
#include<stdio.h>int main(){int i,n;while(scanf("%d",&n)!=EOF){for(i=2;i<n;i++)if(n%i==n)break;if(i==n)printf("Yes\n");elseprintf("No\n");}return 0;}缺点：n稍微⼤点，运⾏时间就会很长，容易时间超限。
普通解法思路：⽐如6，23和32效果是⼀样的，所以只需对它的前⼀半进⾏进⾏判断就可以了。
#include<stdio.h>#include<math.h>int main(){int k,i,n;while(scanf("%d",&n)!=EOF){k=sqrt(n);for(i=2;i<k;i++)if(n%i==n)break;if(i==k)printf("Yes\n");elseprintf("No\n");}return 0;}缺点：效率虽提⾼不少，但n稍微⼤点，运⾏时间还是会很长。
普通筛选法（埃拉托斯特尼筛法）思路：所使⽤的原理是从2开始，将每个素数的各个倍数，标记成合数。
⼀个素数的各个倍数，是⼀个差为此素数本⾝的等差数列。
（百度）#include<stdio.h>int a[1000001]={0};//全局数组，初始化为0，便于后⾯标记int main(){long i,j,n;for(i=2;i<=1000000;i++)if(a[i]==0)for(j=i+i;j<=1000000;j+=i)//⼀个素数的倍数，是⼀个素数本⾝为公差的等差数列，所以每次加ia[j]=1;//将⼀个素数的倍数标记为1while(scanf("%ld",&n)!=EOF){if(a[n]==0&&n!=1)//1不是素数printf("Yes\n");elseprintf("No\n");}return 0;}理解：⽐如开始时i=2，那么2的倍数就⼀定不是素数，所以标记所有2的倍数，同理，3是素数，3的倍数就不是素数，标记为1，当i=4的时候，因为之前被标记过，所以if语句不成⽴，跳过。
判断素数的c语言
判断素数的c语言判断素数的C语言程序素数是指只能被1和本身整除的自然数。
在C语言中，我们可以使用以下方法来判断一个数是否为素数。
方法一：暴力枚举暴力枚举是最简单的方法，即对于每个要判断的数字n，从2到n-1依次判断是否能被整除。
如果存在一个可以整除n的数字，则n不是素数；否则n为素数。
代码实现如下：```c#include <stdio.h>int main(){int n, i, flag = 0;printf("请输入一个正整数：");scanf("%d", &n);for(i=2; i<n; i++){if(n%i == 0){flag = 1;break;}}if(flag == 0)printf("%d是素数\n", n);elseprintf("%d不是素数\n", n);return 0;}```这种方法简单易懂，但效率较低。
当要判断的数字较大时，时间复杂度会非常高。
方法二：优化枚举优化枚举可以减少循环次数，从而提高效率。
具体方法是对于每个要判断的数字n，只需要从2到sqrt(n)依次判断是否能被整除即可。
代码实现如下：```c#include <stdio.h>#include <math.h>int main(){int n, i, flag = 0;printf("请输入一个正整数：");scanf("%d", &n);for(i=2; i<=sqrt(n); i++){if(n%i == 0){flag = 1;break;}}if(flag == 0)printf("%d是素数\n", n);elseprintf("%d不是素数\n", n);return 0;}```这种方法可以减少循环次数，但仍然存在效率较低的问题。
素数常见的算法
求素数的三种方法
素数的定义：
素数也叫质数。
一个大于1的自然数，除了1和它本身之外，不能被其它自然数整除的数叫做素数；能被其它自然数整除的数叫做合数。
规定，1既不是质数也不是合数。
法一：试除法（判断素数）
让N被2如果N能被其中任何一个整数整除，则提前结束循环，N不是素数；如果N不能被其中任何一个整数整除，则N是素数。
代码实现：
法二：埃氏筛法（求一个范围中所有素数）
试除法可以用来判断一个数是否为素数，如果用来求某一范围内所有素数的话，效率就比较低。
埃氏筛法是用来解决这类问题的古老而简单高效的方法，可以快速找到[2,]n中的所有素数。
具体操作是这样的：从2开始寻找素数，每次找到一个素数后就将它的倍数全部筛掉，并将该素数存储到另一个数组中，不断循环，直到原数组为空。
法三：欧拉筛法（埃氏筛法的优化版）
埃氏筛法中，由于一个数可以既是一个素数的倍数，又是另一个素数的倍数，可以发现这会出现重复标记的情况，即同一个数被筛掉了不止一次，浪费操作了。
欧拉筛法就是在埃氏筛法的基础上多了判断的步骤，从而消失了这种重复标记的情况，核心思想是用合数中的一个因数筛掉这个合数。
具体操作为：利用已经求得的素数，第一重循环将区间内的数从小到大遍历，第二重循环将以求得的素数从小到大遍历，将这个数和素数的乘积标记为合数。
如果一个数能被素数整除，跳出循环。
判断素数的5种方法
判断素数的5种方法素数是指只能被1和自身整除的正整数。
在计算机科学和数学领域，判断一个数是否为素数是一个常见且重要的问题。
本文将介绍五种常用的方法来判断一个数是否为素数。
1. 蛮力法蛮力法是最简单直接的方法，也是最容易理解的一种方法。
它通过逐个检查从2到该数字平方根之间的所有可能因子来确定是否为素数。
def is_prime(n):if n <= 1:return Falsefor i in range(2, int(n**0.5) + 1):if n % i == 0:return Falsereturn True该方法的时间复杂度为O(sqrt(n))，其中n是待判断的数字。
2. 费马检测法费马检测法基于费马小定理，该定理表明如果p是一个素数，且a是小于p的正整数，则a^(p-1) ≡ 1 (mod p)。
因此，对于给定的正整数n，选择一个随机整数a，并检查上述等式是否成立。
import randomdef power(x, y, p):res = 1x = x % pwhile y > 0:if y & 1:res = (res * x) % py = y >> 1x = (x * x) % preturn resdef is_prime(n, k=5):if n <= 1 or n == 4:return Falseif n <= 3:return Truewhile k > 0:a = random.randint(2, n - 2)if power(a, n - 1, n) != 1:return Falsek -= 1return True该方法的时间复杂度为O(k * log(n))，其中k是检测次数。
3. 米勒-拉宾检测法米勒-拉宾检测法是费马检测法的改进版本。
它通过选择随机的整数a，并将n-1表示为(2^r)d的形式，其中d是奇数。
判断素数的简单方法
判断素数的简单方法判断素数的简单方法素数，也叫质数，是指只能被1和本身整除的自然数，如2、3、5、7、11等等。
判断一个数是否为素数，是数学中的经典问题之一。
本文将介绍几种简单易行的方法来判断素数。
方法一：暴力枚举法暴力枚举法，顾名思义就是暴力地枚举这个数的所有可能因数。
从2开始到这个数的平方根结束，依次除以这个数。
如果存在一个数能够整除该数，则该数不是素数；否则，该数是素数。
虽然这种方法代码简单易懂，但也存在着效率不高的缺陷。
因为在能被该数整除的因数可能会大于平方根，例如合数15的因数3和5，其中5大于平方根3.87。
方法二：欧拉法则欧拉法则是一种更高效的判断素数的方法。
它的原理是：如果一个数n 是素数，则a^(n-1) mod n = 1，其中a是小于n的任意正整数。
换句话说，如果一个数n不是素数，那么在a^(n-1) mod n时会产生结果0。
虽然这种方法相较于暴力枚举方法在效率上有所提升，但在a^{n-1}mod n非常大的情况下，这种方法仍然不是最佳的选择。
方法三：Miller Rabin算法Miller Rabin算法是一种比较常用的素性判断方法。
它的基本原理是通过不断的随机选择数来尝试将这个数化为2^r * d + 1的形式，其中r和d为正整数，d必须是奇数。
如果d无法算出，则该数肯定不是素数。
如果把Miller Rabin算法的精度调整到足够高的时候，它能够接近100%确定素数。
相较而言，Miller Rabin算法更加高效和精准，但实现起来比较困难。
综上所述，判断素数有许多方法，从简单到复杂、从低效到高效，我们可以根据实际需求选择适合的方法。
在实际使用时，我们应该选择最优化的算法，以提高程序的效率。
素数判断问题
素数判断问题素数是指只能被1和本身整除的自然数。
对于给定的一个数，判断它是否为素数是一个常见且有趣的数学问题。
在本文中，我们将介绍几种素数判断的方法，并通过代码示例来实现。
一、暴力法暴力法是最直接的素数判断方法，即对于给定的数n，遍历从2到n-1的数进行整除运算，如果存在能整除n的数，则n不是素数；否则，n为素数。
代码实现如下：```pythondef is_prime(n):if n <= 1:return Falsefor i in range(2, n):if n % i == 0:return Falsereturn True```以上代码中，我们首先判断n是否小于等于1，因为1不是素数。
然后从2开始遍历到n-1，如果n能被任意一个数整除，则返回False，否则返回True。
这种方法简单易懂，但效率较低。
当n较大时，会进行大量的除法运算，耗费较长的时间。
二、优化方法在暴力法的基础上，我们可以进行一些优化，使判断素数的效率提高。
1. 去除偶数判断：除了2之外，所有的偶数都不可能是素数。
我们可以对代码进行优化，使其在判断n为偶数时直接返回False，减少不必要的运算。
代码实现如下：```pythondef is_prime(n):if n <= 1:return Falseif n == 2:return Trueif n % 2 == 0:return Falsefor i in range(3, int(n ** 0.5) + 1, 2):if n % i == 0:return Falsereturn True```2. 优化循环范围：对于一个数n，如果不存在小于等于n的因子，那么大于n的数也不可能是其因子。
我们只需要判断从2到√n的范围即可。
代码实现如下：```pythondef is_prime(n):if n <= 1:return Falseif n == 2:return Trueif n % 2 == 0:return Falsefor i in range(3, int(n ** 0.5) + 1, 2):if n % i == 0:return Falsereturn True```以上代码中，我们利用`int(n ** 0.5)`可以获取n的平方根，并将循环范围缩小到2到√n。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
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（），其消耗时间很大，特别是在大量数据测试的时候消耗很明显。
这个算法的时间复杂度，与最前面的笨蛋做法就好多了，不过这里好像用sqrt()也没问题啊，，，，这个就不太清楚了。
但是做一个测试发现，如果是这样额话，每一次判断都要计算i*i，而如果只调用sqrt()函数的话，只需要计算一次。
故还是sqrt()函数好一些啊。
对于一个整数N, 需要测试√n-1 次，所以本算法的时间复杂度O(√n)。
4. 再改进一下牛逼的小学生的做法最后，来看一下这个牛逼的小学生，确实，对于一个小学生，能够这么牛逼的想到这么多优化，已经很强大了。
不过其实没什么必要。
这里的i+=2，是因为，偶数除了2之外，是不可能是素数的、所以从3开始，直接+2 。
进一步优化。
这个大概就是朴素判断素数方法的最佳优化了。
（也许你还有更好的优化）所以，如果是对于一般的素数判断的话，用上面那个代码吧小学生毕业了，到了中学，会有怎样的成长呢？下面来看看中学生们是怎么样判断的。
═══════════════════════════════════════════二、埃拉托斯特尼筛选法═══════════════════════════════════════════埃拉托色尼选筛法(the Sieve of Eratosthenes)简称埃氏筛法，是古希腊数学家埃拉托色尼(Eratosthenes 274B.C.～194B.C.)提出的一种筛选法。
是针对自然数列中的自然数而实施的，用于求一定范围内的质数，它的容斥原理之完备性条件是p=H~。
可参考：/wiki/%E5%9F%83%E6%8B%89%E6%89%98%E6%96%AF%E7%89 %B9%E5%B0%BC%E7%AD%9B%E6%B3%95基本原理：筛素数的基本方法是用来筛选出一定范围内的素数素数筛法的基本原理，利用的是素数p只有1和p 这两个约数，并且一个数的约数一定不大于本身，素数筛法的过程：把从1开始的、某一范围内的正整数从小到大顺序排列，1不是素数，首先把它筛掉。
剩下的数中选择最小的数是素数，然后去掉它的倍数。
依次类推，直到筛子为空时结束。
求解用途：素数筛法经常作为一道题的一部分用来打一定范围内素数表，然后利用素数表作为基础解题。
*/执行完本算法之后，isprime[i]中如果是1，表示i为素数，0，表示i不是素数。
所以呢，这个算法执行完一遍之后，就可以在O(1)的时间内判断出MAX以内的任意数，是不是素数了，所以这个算法消耗的时间可以说全部在筛选上了。
初看这个算法，会觉得这个算法的时间复杂度是O(N^2)，，但其实不是的，在第二个循环中，每次递增的i，当i越来也大的时候，j很快就能超过MAX的，筛选法的实际复杂度是O(n*log(logn)）2. 有思想的中学生的做法*这个算法的关键在于if(i % p[j] == 0) break;，它使得任何一个合数，只能被它最小的质因数标记过一次，再一次进行优化。
所以整个算法是线性的。
但考虑到log(log(100000000))还不到3，故这个线性算法其实也只有理论的价值罢了。
其实我不这样认为。
这样其实可以当成素数表来用，因为定义了一个数组p，存放的都是素数。
讲到这里，你应该对判断素数这个问题有了一个新的认识了。
既要考虑时间上的问题。
又要考虑空间上的问题。
也就是这并不是一个无脑问题。
═══════════════════════════════════════════三、朴素判断+ 筛选法═══════════════════════════════════════════那位聪明的小学生已经将朴素法优化到很好了。
再深入理解，你确实会发现一个本质问题。
从2到√n 中，存在很多不必要的判断，比如，n不能被2整除的话，n必然不能被4整除，必然不能被2的倍数整除。
所以，我们再结合筛选法，优化处理小于√n 的所有素数。
这样在大量测试数据的时候，效率就提高很多了。
上面这个代码，就是将两种方法完美结合了，上面的算法，总的时间复杂度理论上是0(√n)。
但是字常数上已经得到很大的优化了，效率上也比原来的朴素快了好多。
别人统计是快了几十倍吧。
这个我不清楚。
但是你会发现始终有一个问题，单纯用筛选法耗空间太多，用朴素法耗时间太多，有没有其他的办法？事实证明是有的。
下面将会接受两种方法，一种是费马测试，一种是米勒拉宾测试。
这两个测试就有点难了，至少对于我来说有点难了。
═══════════════════════════════════════════四、费马素数测试══════════════════════════════════════════════════════════════════════════════════════费马小定理：有N为任意正整数，P为素数，且N不能被P整除（显然N和P互质），则有：N^P%P=N(即：N的P次方除以P的余数是N)公式变形：(N^(P-1))%P=1网络分析：后来分析了一下，两个式子其实是一样的，可以互相变形得到，原式可化为：(N^P-N)%P=0(即：N的P次方减N可以被P整除，因为由费马小定理知道N的P次方除以P的余数是N)把N提出来一个，N^P就成了你N*(N^(P-1))，那么(N^P-N)%P=0可化为：(N*(N^(P-1)-1))%P=0请注意上式，含义是：N*(N^(P-1)-1)可以被P整除又因为N*(N^(P-1)-1)必能整除N（这不费话么!）所以，N*(N^(P-1)-1)是N和P的公倍数，小学知识了^_^又因为前提是N与P互质，而互质数的最小公倍数为它们的乘积，所以一定存在正整数M使得等式成立：N*(N^(P-1)-1)=M*N*P两边约去N，化简之：N^(P-1)-1=M*P因为M是整数，显然：(N^(P-1)-1)%P=0即：N^(P-1)%P=1═══════════════════════════════════════════积模分解公式先有一个引理，如果有：X%Z=0，即X能被Z整除，则有：(X+Y)%Z=Y%Z这个不用证了吧...设有X、Y和Z三个正整数，则必有：(X*Y)%Z=((X%Z)*(Y%Z))%Z想了很长时间才证出来，要分情况讨论才行：1.当X和Y都比Z大时，必有整数A和B使下面的等式成立：X=Z*I+A（1）Y=Z*J+B（2）不用多说了吧，这是除模运算的性质！将（1）和（2）代入(X*Y)modZ得：((Z*I+A)(Z*J+B))%Z乘开，再把前三项的Z提一个出来，变形为：(Z*(Z*I*J+I*A+I*B)+A*B)%Z（3）因为Z*(Z*I*J+I*A+I*B)是Z的整数倍……晕，又来了。
概据引理，（3）式可化简为：(A*B)%Z又因为：A=X%Z，B=Y%Z，代入上面的式子，就成了原式了。
2.当X比Z大而Y比Z小时，一样的转化：X=Z*I+A代入(X*Y)%Z得：(Z*I*Y+A*Y)%Z根据引理，转化得：(A*Y)%Z因为A=X%Z，又因为Y=Y%Z，代入上式，即得到原式。
同理，当X比Z小而Y比Z大时，原式也成立。
3.当X比Z小，且Y也比Z小时，X=X%Z，Y=Y%Z，所以原式成立。
═══════════════════════════════════════════快速计算乘方的算法如计算2^13，则传统做法需要进行12次乘法。
/*计算n^p*/把2*2的结果保存起来看看，是不是成了：4*4*4*4*4*4*2再把4*4的结果保存起来：16*16*16*2一共5次运算，分别是2*2、4*4和16*16*16*2这样分析，我们算法因该是只需要计算一半都不到的乘法了。
为了讲清这个算法，再举一个例子2^7：2*2*2*2*2*2*2两两分开：(2*2)*(2*2)*(2*2)*2如果用2*2来计算，那么指数就可以除以2了，不过剩了一个，稍后再单独乘上它。
再次两两分开，指数除以2：((2*2)*(2*2))*(2*2)*2实际上最后一个括号里的2 * 2是这回又剩下的，那么，稍后再单独乘上它现在指数已经为1了，可以计算最终结果了：16*4*2=128优化后的算法如下：够完美了吗？不，还不够！看出来了吗？main是没有必要的，并且我们可以有更快的代码来判断奇数。
要知道除法或取模运算的效率很低，所以我们可以利用偶数的一个性质来优化代码，那就是偶数的二进制表示法中的最低位一定为0!其实位运算这个东西我一直也没高太懂，有时间要系统得搞清楚如果我们现在要对非常非常大的数进行判断，素数表显得无能为力了。
还有就是可以用动态的素数表来进行优化，这就是大学生的做法了。
但是动态生成素数表的策略又复杂又没有效率，所以我们还是直接跳跃到专家的做法吧：根据上面讲到的费马小定理，对于两个互质的素数N和P，必有：N^(P-1)%P=1那么我们通过这个性质来判断素数吧，当然，你会担心当P很大的时候乘方会很麻烦。