【算法】筛选法统计素数--埃拉托色尼筛

埃拉托色尼的筛子

生成素数有很多方法，本文介绍的算法是一种高效的筛选算法 ---埃拉托色尼筛选法。

比如，要产生[2,n] 范围内的所有素数，步骤如下：

 

1、构造一个2,3,4,5,...n 的候选数序列 A 。

2、不断的去除（筛掉）序列A中的非素数。

     ①去掉2的倍数 。

     ②再去掉3的倍数。

     ③去掉4的倍数（不需要，因为在第一步已经被去掉了）  去掉5的倍数。

     ④去掉6的倍数

     ⑤去掉7 的倍数

        ... ...   一直到不能再去除为止。

 

3、经过反复的筛选去除后，序列A就只剩下了[2,n]内的素数

 

 

例子：产生[2,25]范围的素数序列

 

 

 

代码实现

 

/*
使用一个bool 数组。数组的下标代表待筛选的数，而用数组元素的值代表 数的存在与否。

如 A[p] = true  表示数p 存在，没有被去除。则p为素数

*/

void select_prime(int n)
{
    if (n < 2) return ;              
    
    const bool exist     = true;
    const bool not_exist = false;


    bool*A = new bool[n + 1];    //会浪费 数组的第一 和第二个元素空间.因为 0 和 1 既不是素数，也不是合数。
    memset(A, exist, sizeof(bool)*(n + 1));  //初始化为exist

    for (int p = 2; p*p <=n; p++)
    {
        if (A[p] == exist)         //
        {                          //
            int j = p*p;          //
            while (j <= n)        //
            {                     //
                A[j] = not_exist; //
                j += p;           // 
            }                     //
        }                         //
    }

    //至此 ，使得A[p]为true 的p都是素数。这里不再具体操作，取决于你自己的实现。如打印，或者转存

    delete[] A;

}

 

 

代码解读

整体代码，估计就是for循环那段代码可能不好理解。我们先分析for内部的代码。

if (A[p] == exist)        //如果p是素数
 {                        
      int j = p*p;   //则从p*p开始 去除
      while (j <= n)        
      {                     
           A[j] = not_exist;    //标记为   去除状态
           j += p;              //递增到下一个倍数
      }                     
}      

  

 

也就是说，对于一个数p，会依次去除  p*p  ,  p(p+1) , p(p+2) .... p(p+k)   【p(p+k)<=n】

前面不是说要去除 p 的所有倍数的吗？那 2p ,3p  4p ...p(p-1)怎么不去除呢？

他们已经被去除了。因为当前我们要消去 p 的倍数，那么，之前一定去除了 p-1 , p-2 ，p-3 ... 4 ， 3 ， 2  的这些数 的倍数，So ， p(p-1)  , p(p-2) .... p3  p2 显然在之前的操作中被去除。

也正是因为这个原因，最外面的for循环，p 的值从 2  到   ，而不必从 2 到 n。为了避免使用sqrt函数带来消耗，我使用了乘法，是同样的效果。

 

即便通过技巧减少不必要的去除操作，上面的代码依然存在重复去除的可能。比如数字35，在去除5的倍数时被标记为  去除 ，在去除7的倍数时，也会再次被标记 。当然这不影响结果的正确性。但是如果要统计素数的个数，就需要小小的修改一下代码了。

 

统计素数的个数

 

int countPrime(int n)
{
    if (n < 2) return 0;

    const bool exist = true;
    const bool not_exist = false;

    unsigned  count = n - 1;      //假设全部是素数
    

    bool*A = new bool[n + 1];   
    memset(A, exist, sizeof(bool)*(n + 1));

    for (int p = 2; p*p <= n; p++)
    {
        if (A[p] == exist)
        {
            int j = p*p;
            while (j <= n)
            {
                if (A[j] == exist)     //只有没被去除，才做去除操作。避免重复统计
                {
                    A[j] = not_exist;
                    count--;           //减少1个
                }
                j += p;
            }
        }
    }


    delete[] A;

    return count;

}

 

这个算法的速度比我的这篇文章中最好的solution还要快10倍，很是强悍。但有个缺点就是空间复杂度为O(n)。

 

使用这个算法解决leetcode题目后的runtime统计，可以发现这个算法超越了98.89%的Ac。