nyoj_187_快速查找素数_201312042102

快速查找素数

时间限制：1000 ms  |           内存限制：65535 KB

难度：3

 

描述

现在给你一个正整数N，要你快速的找出在2.....N这些数里面所有的素数。

 

输入

给出一个正整数数N(N<=2000000) 但N为0时结束程序。 测试数据不超过100组

输出

将2~N范围内所有的素数输出。两个数之间用空格隔开

样例输入

5
10
11
0

样例输出

2 3 5
2 3 5 7
2 3 5 7 11

来源

经典题

#include <stdio.h>
#define MAX 2000000
int a[MAX+1]={0};
int main()
{
    int i,j,n;
    for(i=2;i<=MAX;i++)
    {
        if(a[i]==0)
        {
            for(j=i+i;j<=MAX;j+=i)
            {
                a[j]=1;
            }
        }
    }
    while(scanf("%d",&n),n)
    {
        for(i=2;i<=n;i++)
        if(!a[i])
        printf("%d ",i);
        printf("
");
    }
    return 0;
}

本题最优代码：（虽然暂时没看懂）

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cmath>
using namespace std;
const int M1=2000100,M2=1000000;
bool NotPrime[M1]={1,1,0};
int Prime[M2];
int PrimeNum=0;
int main()
{
 int n;
 for(int i=2;i<=1415;i++)
 if(!NotPrime[i])
 { 
 Prime[PrimeNum++]=i;
 for(int j=i*i;j<=2000000;j+=i)
 {
 NotPrime[j]=1;
 }
 }
 for(int i=Prime[PrimeNum-1]+1;i<=2000000;i++)
 if(!NotPrime[i]) Prime[PrimeNum++]=i;
 while(scanf("%d",&n)&&n)
 {
 for(int i=0;Prime[i]<=n && Prime[i];i++)
 printf("%d ",Prime[i]);
 puts("");
 }
} 

快速查找素数方法：
链接：http://blog.csdn.net/liwen_7/article/details/6622405

【问题描述】：
　　　　试编写一个程序，找出2->N之间的所有质数。希望用尽可能快的方法实现。

【问题分析】：
　　　　这个问题可以有两种解法：一种是用“筛子法”，另一种是从2->N检查，找出质数。
　　　　先来简单介绍一下“筛法”，求2~20的质数，它的做法是先把2~20这些数一字排开：
　　　　2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
　　　　先取出数组中最小的数，是2，则判断2是质数，把后面2的倍数全部删掉。
　　　　2 | 3　5 7 9 11 13 15 17 19
　　　　接下来的最小数是3，取出，再删掉3的倍数
　　　　2 3 | 5 7 11 13 17 19
　　　　一直这样下去，直到结束。
　　　　筛法求质数的问题时，非质数的数据有很多是重复的。例如，如果有一个数3×7×17×23，那么在删除3的倍数时会删到它，删7、17、23时同样也会删到它。有一种“线性筛法”，可以安排删除的次序，使得每一个非质数都只被删除一次。从而提高效率。因为“筛法”不是我要介绍的重点，所以就不介绍了。
　　　　现在我来介绍第二种方法。用这种方法，最先想到的就是让从2~N逐一检查。如果是就显示出来，如果不是，就检查下一个。这是正确的做法，但效率却不高。当然，2是质数，那么2的倍数就不是质数，如果令i从2到N，就很冤枉地测试了4、6、8……这些数？所以第一点改建就是只测试2与所有的奇数就足够了。同理，3是质数，但6、9、12……这些3的倍数却不是，因此，如果能够把2与3的倍数跳过去而不测试，任意连续的6个数中，就只会测试2个而已。以6n,6n+1,6n+2,6n+3,6n+4,6n+5为例，6n,6n+2,6n+4是偶数，又6n+3是3的倍数，所以如果2与3的倍数都不理会，只要测试的数就只留下6n+1和6n+5而已了，因而工作量只是前面想法的2/6=1/3，应该用这个方法编程。
　　　　还有个问题，就是如果判断一个数i是否为素数。按素数的定义，也就是只有1与本身可以整除，所以可以用2~i-1去除i，如果都除不尽，i就是素数。观点对，但却与上一点一样的笨拙。当i>2时，有哪一个数可以被i-1除尽的？没有，为什么？如果i不是质数，那么i=a×b，此地a与b既不是i又不是1；正因为a>1，a至少为2，因此b最多也是i/2而已，去除i的数用不着是2~i-1，而用2~i/2就可以了。不但如此，因为i=a×b，a与b不能大于sqrt(i),为什么呢？如果a>sqrt(i),b>sqrt(i),于是a×b>sqrt(i)*sqrt(i)=i，因此就都不能整除i了。如果i不是质数，它的因子最大就是sqrt(i)；换言之，用2~sqrt(i)去检验就行了。
　　　　但是，用2~sqrt(i)去检验也是浪费。就像前面一样，2除不尽，2的倍数也除不尽；同理，3除不尽，3的倍数也除不尽……最理想的方法就是用质数去除i。
　　　　但问题是这些素数从何而来？这比较简单，可以准备一个数组prime[]，用来存放找到的素数，一开始它里面有2、3、5。检查的时候，就用prime[]中小于sqrt(i)的数去除i即可，如果都除不尽，i就是素数，把它放如prime[]中，因此prime[]中的素数会越来越多，直到满足个数为止！
　　　　不妨用这段说明来编写这个程序，但是程序设计的时候会有两个小问题：
　　　　1.如果只检查6n+1和6n+5？不难发现，它们的距离是4、2、4、2……所以，可以先定义一个变量gab=4，然后gab=6-gab;
　　　　2.比较是不能用sqrt(i)，因为它不精确。举个例子，i=121，在数学上，sqrt(i)自然是11，但计算机里的结果可能是10.9999999，于是去除的数就是2、3、5、7，而不含11，因此121就变成质数了。解决这个问题的方法很简单，不要用开方，用平方即可。例如，如果p*p<=i，则就用p去除i。而且它的效率比开方高。

【程序清单】：

#include <stdio.h>
#include <string.h>
int f[1000000];
int main()
{
    int n;
    while(scanf("%d",&n),n)
    {
        int t;
        int i,j,k;
        int gad=4;
        int count;
        memset(f,0,sizeof(f));        
        f[0]=2;f[1]=3;f[2]=5;
        if(n>1){
        printf("2");
        for(t=1;f[t]<=n&&f[t]!=0;t++)
        printf(" %d",f[t]);
        for(k=3,i=7;i<=n;i+=gad)
        {
            count = 1;
            gad=6-gad;
            for(j=0;f[j]*f[j]<=i;j++)
            {
                if(i%f[j]==0)
                count=0;
                break;
            }
            if(count)
            {
                f[k++]=i;

                printf(" %d",i);
            }
        }
        printf("
");
    }
    }
    return 0;
}