改进筛素数法

改进前的筛素数法：

原理：一个素数的倍数必然不是素数；

const int MAXN = 100;
bool flag[MAXN];
int primes[MAXN / 3], pi;
bool flag2[MAXN];

方法一：

void GetPrime_1()
{
    int i, j;
    pi = 0;
    memset(flag, false, sizeof(flag));   //false代表是素数；素数存到了primes数组；
    for (i = 2; i < MAXN; i++)
        if (!flag[i])
        {
            primes[pi++] = i;
            for (j = i; j < MAXN; j += i)
                flag[j] = true;
        }
}

方法二：

void GetPrime_2()
{
    int i,j;
    memset(flag2,0,sizeof(flag2));// 0 代表是素数；0代表素数，1代表非素数；
    flag2[0]=1,flag2[1]=1;
    for(i=2; i<MAXN; i++)
    {
        for(j=2*i; j<MAXN; j+=i)
        {
            flag2[j]=1;
        }
    }
}
                                   //注意调用本函数如果想要一行x字符输出的话的程序编写；

判断一个整数是否为素数：

int judge_prime(int n)
{
  int m;
  if(n<2)
    return 0;
  m=floor(sqrt(n)+0.5);
  for(int i=2;i<=m;i++)
  {
    if(n%i==0)
      return 0;
  }
  return 1;
}

改进后的筛素数法：

const int MAXN = 100;
bool flag[MAXN];
int primes[MAXN / 3], pi;
void GetPrime_2()
{
    int i, j;
    pi = 0;
    memset(flag, false, sizeof(flag));
    for (i = 2; i < MAXN; i++)
    {
        if (!flag[i])
            primes[pi++] = i;
        for (j = 0; (j < pi)  && (i * primes[j] < MAXN); j++)
        {
            flag[i * primes[j]] = true;
            if (i % primes[j] == 0) //这句保证每个非素数只被筛去一次
                break;
        }
    }
}

改进原理：

一.任何一个数与其它所有素数的乘积必然也不是素数（这是因为每个合数必有一个最小素因子）

我们的要求是让每个合数仅被它的最小素因子筛去一次。比如12，它的最小素因子是2，所以就只应该被在计算6*2时去访问，而且不应该在计算4*3时去访问，同理18也只应该被在计算9*2时去访问，而且不应该在计算6*3时去访问。

 找到原因后，再来思考如何解决。6*3不行而9*2可以了，是因为6是2的倍数，所以在计算6*2之后就不能再将6与比2大的素数相乘，这些相乘的结果必定会导致重复计算。因此对于任何数来说，如果它如果是该素数的倍数那么它就不能再与素数表中该素数之后的素数相乘了，如9是3的倍数，所以在9*3之后就不能再去用计算9*5了。因此在代码中再增加一行判断语句;

想知道这二种筛素数法方法的区别吗？现在对求2到1亿之间的素数进行测试，看看区别到底会有多大，测试代码如下：

[cpp]  view plain  copy

1. // 普通的筛素数方法与改进之后的效率对比  
2. // by MoreWindows( http://blog.csdn.net/MoreWindows )     
3. #include <stdio.h>  
4. #include <memory.h>  
5. #include <time.h>  
6. #include <math.h>  
7. const int MAXN = 100000000;  
8. bool flag[MAXN];  
9. int primes[MAXN / 3], pi;  
10. // 利用对每个素数的倍数必定不是素数来筛选  
11. void GetPrime_1()  
12. {  
13.     int i, j;  
14.     pi = 0;  
15.     memset(flag, false, sizeof(flag));  
16.     for (i = 2; i < MAXN; i++)  
17.         if (!flag[i])  
18.         {  
19.             primes[pi++] = i;  
20.             for (j = i; j < MAXN; j += i)  
21.                 flag[j] = true;  
22.         }  
23. }  
24. // 利用了每个合数必有一个最小素因子来筛选  
25. void GetPrime_2()  
26. {  
27.     int i, j;  
28.     pi = 0;  
29.     memset(flag, false, sizeof(flag));  
30.     for (i = 2; i < MAXN; i++)  
31.     {  
32.         if (!flag[i])  
33.             primes[pi++] = i;  
34.         for (j = 0; (j < pi)  && (i * primes[j] < MAXN); j++)  
35.         {  
36.             flag[i * primes[j]] = true;  
37.             if (i % primes[j] == 0)  
38.                 break;  
39.         }  
40.     }  
41. }  
42. int main()  
43. {  
44.     printf(" 在%d的数据量下普通的筛素数方法与改进之后的效率对比\n", MAXN);  
45.     printf("  by MoreWindows( http://blog.csdn.net/MoreWindows ) -- --\n\n");  
46.     clock_t clockBegin, clockEnd;  
47.       
48.     clockBegin = clock();  
49.     GetPrime_1();  
50.     clockEnd = clock();  
51.     printf("普通的筛素数方法\t%d毫秒\n", clockEnd - clockBegin);  
52.       
53.     clockBegin = clock();  
54.     GetPrime_2();  
55.     clockEnd = clock();  
56.     printf("改进的筛素数方法\t%d毫秒\n", clockEnd - clockBegin);  
57.     return 0;  
58. }  

测试结果如图所示：

    可以看出，效率有4倍之差。改进还是比较可观。有兴趣的同学可以参考下一篇《位操作基础篇之位操作全面总结》所讲到的空间压缩技巧来将改进后的筛素数法方进行空间压缩。

    文章最后作下小小总结：

1．普通的筛素数的原理是一个素数的倍数必须不是素数。

2．改进的筛素数的原理是每个合数必有一个最小素因子，根据每个最小素因子去访问合数就能防止合数被重复访问。

/***********************************原文链接： http://blog.csdn.net/morewindows/article/details/7347459************************************/