素数判断与筛法-优快云博客

There is a basic way to judge whether a number is a prime:

int isprime(int x)
{
    int i;
    float fx,sqrtx;
    if(x<=1)
       return 0;
    else if(x==2)
       return 1;
    else
    {
        if(x%2==0)
          return 0;
        else
        {
            fx=x;
            sqrtx=sqrt(fx);
            for(i=3;i<=sqrtx;i+=2)
               if( x%i==0 )
                  return 0;
            return 1;
        }
    }    
}

sieve of Eratosthenes：

void getPrime()
{//筛法 
    int i,j;
    int bound=sqrt((double)n);
    for(i=2;i<n;i++)prime[i]=1;//将所有的数置1，表示这些数都是素数.
    for(i=2;i<bound;i++)
	{//注意从2开始
      for(j=i+i;j<n;j+=i)//将2的倍数置成0，表示不是素数
		prime[j]=0;
    }
}

快速线性筛法

快速线性筛法没有冗余，不会重复筛除一个数，所以“几乎”是线性的，虽然从代码上分析，时间复杂度并不是O(n)。先上代码

int CalPrimes()
{
	const long N = 200;
	long prime[N] = { 0 }, num_prime = 0;
	int isNotPrime[N] = { 1, 1 };
	for (long i = 2; i < N; ++i)
	{
		if (!isNotPrime[i])
		{
			prime[num_prime++] = i;
		}
		//关键处1
		for (long j = 0; j < num_prime && i*prime[j] < N; ++j)
		{
			isNotPrime[i*prime[j]] = 1;
			if (!(i%prime[j])) //关键处2
				break;
		}
	}
	return 0;
}

首先，先明确一个条件，任何合数都能表示成一系列素数的积。

不管 i 是否是素数，都会执行到“关键处1”，

①如果 i 都是是素数的话，那简单，一个大的素数 i 乘以不大于 i 的素数，这样筛除的数跟之前的是不会重复的。筛出的数都是 N=p1*p2的形式, p1，p2之间不相等

②如果 i 是合数，此时 i 可以表示成递增素数相乘 i=p1*p2*...*pn, pi都是素数（2<=i<=n）， pi<=pj ( i<=j )

p1是最小的系数。

根据“关键处2”的定义，当p1==prime[j] 的时候，筛除就终止了，也就是说，只能筛出不大于p1的质数*i。

我们可以直观地举个例子。i=2*3*5

此时能筛除 2*i ,不能筛除 3*i

如果能筛除3*i 的话，当 i' 等于 i'=3*3*5 时，筛除2*i' 就和前面重复了。

需要证明的东西：

一个数会不会被重复筛除。
合数肯定会被干掉。

根据上面红字的条件，现在分析一个数会不会被重复筛除。

设这个数为 x=p1*p2*...*pn, pi都是素数（1<=i<=n) , pi<=pj ( i<=j )

当 i = 2 时，就是上面①的情况，

当 i >2 时，就是上面②的情况，对于 i ，第一个能满足筛除 x 的数 y 必然为 y=p2*p3...*pn（p2可以与p1相等或不等），而且满足条件的 y 有且只有一个。所以不会重复删除。

证明合数肯定会被干掉？用归纳法吧。

类比一个模型，比如说我们要找出 n 中2个不同的数的所有组合 { i , j } ，1<=i<=n, 1<=j<=n,

我们会这么写

for (i=1; i<n; ++i )

for (j=i+1; j<=n; ++j)

{

/////

}

我们取 j=i+1 便能保证组合不会重复。快速筛法大概也是这个道理，不过这里比较难理解，没那么直观。

1楼提供的方法，我整理下

//偶数显然不行，所以先去掉偶数。可以看作上面第一种的优化吧。但是这种方法还是没有解决掉一个数被多次去除的情况。。。

//不过这种方法不太直观，不太好理解。

//我推荐这个算法！ 易于理解。 只算奇数部分，时空效率都还不错！
//但是这个算法也适合oj刷题，并没有利用快速筛法只筛一次的性质，例如3*3*5会被3*3的时候筛，也会被3*5的时候筛
half=SIZE/2;
int sn = (int) sqrt(SIZE);
for (i = 0; i < half; i++)
   p[i] = true;// 初始化全部奇数为素数。p[0]对应3，即p[i]对应2*i+3
for (i = 0; i < sn; i++) {
if(p[i])//如果 i+i+3 是素数  
{
    for(k=i+i+3, j=k*i+k+i; j < half; j+=k)
    // 筛法起点是 p[i]所对应素数的平方 k^2
    // k^2在 p 中的位置是 k*i+k+i  
    //    下标 i： k*i+k+i  
    //对应数值 k=i+i+3   k^2
       p[j]=false;   
}   
}   
//素数都存放在 p 数组中，p[i]=true代表 i+i+2 是素数。  
//举例，3是素数，按3*3,3*5,3*7...的次序筛选，因为只保存奇数，所以不用删3*4，3*6....