筛法，埃氏筛法 Eular筛法

用筛法求 素数的基本思想是：把从1开始的、某一范围内的 正整数从小到大顺序排列， 1不是素数，首先把它筛掉。剩下的数中选择最小的数是素数，然后去掉它的 倍数。依次类推，直到筛子为空时结束。如有：

1 2 3 4 5 6 7 8 9 10

11 12 13 14 15 16 17 18 19 20

21 22 23 24 25 26 27 28 29 30

1不是素数，去掉。剩下的数中2最小，是素数，去掉2的倍数，余下的数是：

3 5 7 9 11 13 15 17 19 21 23 25 27 29

剩下的数中3最小，是素数，去掉3的倍数，如此下去直到所有的数都被筛完，求出的素数为：

2 3 5 7 11 13 17 19 23 29

代码实现：

#include
#include
#include
#include
using namespace std;
int a[1000000];
int main()
{
    int n;
    scanf("%d", &n);
    a[0] = a[1] = 1;
    for(int i = 2; i < 1000000; i++)
    {
        if(!a[i])
            for(int j = 2; i*j < 1000000; j++)
        {
            a[i*j] = 1;
        }
    }
    if(!a[n])
        printf("该数为素数！\n");
    else
        printf("该数不是素数！\n");
}

要得到自然数n以内的全部素数，必须把不大于

n

的所有素数的倍数剔除，剩下的就是素数。

Eratosthenes筛法：

给出要筛 数值的范围n，找出以内的 素数。先用2去筛，即把2留下，把2的倍数剔除掉；再用下一个 质数，也就是3筛，把3留下，把3的倍数剔除掉；接下去用下一个质数5筛，把5留下，把5的 倍数剔除掉；不断重复下去......。

步骤

详细列出算法如下：

1. 列出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，序列变成：
   • 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
3. 将剩下序列中，划掉2的倍数，序列变成：
   • 2 3 5 7 9 11 13 15 17 19 21 23 25
4. 如果现在这个序列中最大数小于最后一个标出的素数的平方，那么剩下的序列中所有的数都是素数，否则回到第二步。
5. 本例中，因为25大于2的平方，我们返回第二步：
6. 剩下的序列中第一个素数是3，将主序列中3的倍数划掉，主序列变成：
   • 2 3 5 7 11 13 17 19 23 25
7. 我们得到的素数有：2，3
8. 25仍然大于3的平方，所以我们还要返回第二步：
9. 现在序列中第一个素数是5，同样将序列中5的倍数划掉，主序列成了：
   • 2 3 5 7 11 13 17 19 23
10. 我们得到的素数有：2，3，5 。
11. 因为23小于5的平方，跳出循环. ：2到25之间的素数是：2 3 5 7 11 13 17 19 23。
12. 代码实现：

    #include
    #include
    #include
    #include
    using namespace std;
    int a[1000000];
    int main()
    {
        int n;
        scanf("%d", &n);
        a[0] = a[1] = 1;
        for(int i = 2; i < sqrt(n); i++)
        {
            if(!a[i])
                for(int j = i*i; j <= n; j += i)
            {
                a[j] = 1;
            }
        }
        if(!a[n])
            printf("该数为素数！\n");
        else
            printf("该数不是素数！\n");
    }
    

    Eular筛法：（转载自： 点击打开链接）

13. 使用Eular筛法。bool数组isprim表示是否为质数，prime记录质数，对于外层枚举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，这样也就造成了多次重复计算了。

14.      

    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;
                }
            }
        }
    }