判断素数的几种方法的总结

素数，又称质数，定义是：除了1和它本身以外不再有其他的除数整除。

方法一

按照定义，从2到n-1判断有没有能整除n的数。如果有，则不是素数，否则，是素数

bool is_prime(int n){
    if (n < 2){
        return false;
    }
    int i;
    for (i = 2; i < n; i++){
        if (n%i == 0){
            return false;
        }
    }
    return true;
}

算法复杂度：O(n)

方法二

还是按照定义，不过是从2一直算到sqrt(n)，这样算法复杂度降低了很多

bool is_prime(int n){
    if (n < 2){
        return false;
    }
    int i;
    for (i = 2; i*i <= n; i++){
        if (n%i == 0){
            return false;
        }
    }
    return true;
}

方法三

米勒拉宾素数测试的方法

米勒拉宾证明起来很麻烦(准确的说是博主也不会 -_-#)

直接上模板吧

int tab[]={2, 3, 5, 7};
long long qpow(int a, int b, int r)  //(a^b)%r 快速幂取模
{
    long long ret = 1, tmp = a;
    while(b)
    {
        if (b&1)
            ret = ret*tmp%r;
        tmp = tmp*tmp%r;
        b >>= 1;
    }
    return ret; 
}
bool  Miller_Rabbin(int n, int a)//米勒拉宾素数测试 
{
    int r = 0, s = n-1, j;
    long long k;
    if(n%a == 0)    return false;
    while((s&1) == 0)
    {
        s >>= 1;
        r++;
    }
    k = qpow(a, s, n);
    if(k == 1)  return true;
    for (j = 0; j < r; j++, k=k*k%n)
        if (k == n-1)
            return true;
    return false;
}
bool Isprime(int n)//判断是否是素数 
{
    for (int i = 0; i < 4; i++)
    {
        if (n == tab[i])
            return true;
        if (!Miller_Rabbin(n, tab[i]))
            return false;
    }
    return true;
}

方法四

上面几种方法都只能判断一个数是不是素数，当需要判断1-n里面有多少素数时，就会很麻烦，有一种较为简单的方法就是Eratosthenes筛法

如果一个数是素数，那么这个数的倍数一定不是素数，就是这个思想，把所有的非素数都去掉

bool flag[N];
void fun(){
    long long i, j;
    for (i = 0; i < N; i++){
        flag[i] = true;
    }
    flag[0] = flag[1] = false;
    for (i = 2; i < N; i++){
        if (!flag[i])   continue;
        for (j = i*i; j < N; j += i){
            flag[j] = false;
        }
    }
}

算法复杂度O(n*log log n)
但是这个算法有一个冗余的地方：比如合数10，在枚举2的时候我们判定了一次，在枚举5的时候我们又判定了一次。因此使得其时间复杂度比O(n)要高。

方法五

我们可以知道，任意一个正整数k，若k≥2，则k可以表示成若干个质数相乘的形式。Eratosthenes筛法中，在枚举k的每一个质因子时，我们都计算了一次k，从而造成了冗余。因此在改进算法中，只利用k的最小质因子去计算一次k。
与Eratosthenes筛法不同的是，对于外层枚举i，无论i是质数，还是是合数，我们都会用i的倍数去筛。但在枚举的时候，我们只枚举i的质数倍。比如2i,3i,5i,…，而不去枚举4i,6i…，原因我们后面会讲到。

此外，在从小到大依次枚举质数p来计算i的倍数时，我们还需要检查i是否能够整除p。若i能够整除p，则停止枚举。

利用该算法，可以保证每个合数只会被枚举到一次。我们可以证明如下命题：

假设一个合数k=M*p1，p1为其最小的质因子。则k只会在i=M，primeList[j]=p1时被筛掉一次。

首先会在i=M，primeList[j]=p1时被筛掉是显然的。因为p1是k的最小质因子，所以i=M的所有质因子也≥p1。于是j循环在枚举到primeList[j]=p1前不会break，从而一定会在i=M，primeList[j]=p1时被筛掉

其次不会在其他时候被筛掉。否则假设k在i=N, primeList[j]=p1时被筛掉了，此时有k=N*p2。由于p1是k最小的质因子，所以p2 > p1，M > N且p|N。则i=N，j枚举到primeList[j]=p1时(没到primeList[j]=p2)就break了。所以不会有其他时候筛掉k。

同时，不枚举合数倍数的原因也在此：对于一个合数k=M*2*3。只有在枚举到i=M*3时，才会计算到k。若我们枚举合数倍数，则可能会在i=M时，通过M*6计算到k，这样也就造成了多次重复计算了。

综上，Eular筛法可以保证每个合数只会被枚举到一次，时间复杂度为O(n)。当N越大时，其相对于Eratosthenes筛法的优势也就越明显。

int primelist[N], primecount = 0;
bool isprime[N];
void eular(int n){ int i, j; for (i = 0; i <= n; i++){ isprime[i] = true; }
    isprime[0] = isprime[1] = false;
    for (i = 2; i <= n; i++){ if (isprime[i]){ primelist[primecount++] = i; }
        for (j = 0; j < primecount; j++){ if (i*primelist[j] > n){ break; }
            isprime[i*primelist[j]] = false;
            if (i%primelist[j]==0){
                break;
            }
        }
    }
}