求质数的几种方法

http://blog.sina.com.cn/s/blog_622e77cc0100n5lm.html

1、根据质数的定义求
　　质数定义：只能被1或者自身整除的自然数（不包括1），称为质数。
　　利用它的定义可以循环判断该数除以比它小的每个自然数（大于1），如果有能被它整除的，则它就不是质数。
对应代码是：
void printPrime(int n){//判断n是否是质数
        boolean isPrime=true;//是否是质数的标志
        for(int i=n-1;i>1;i—){//n除以每个比n小比1大的自然数
            if(n%i==0){//如果有能被整除的，则不是质数
                isPrime=false;
            }
        }
        if(isPrime){//如果是质数，则打印出来
            System.out.print(n+" ");
            primeNumber++;//记录质数的个数
            if(primeNumber%10==0)//输出10个质数后换行
                System.out.println();
        }
}
2、利用一个定理——如果一个数是合数，那么它的最小质因数肯定小于等于他的平方根。例如：50，最小质因数是2，2<50的开根号
再比如：15，最小质因数是3，3<15的开根号
　　合数是与质数相对应的自然数。一个大于1的自然数如果它不是合数，则它是质数。
　　上面的定理是说，如果一个数能被它的最小质因数整除的话，那它肯定是合数，即不是质数。所以判断一个数是否是质数，只需判断它是否能被小于它开跟后后的所有数整除，这样做的运算就会少了很多，因此效率也高了很多。
对应代码是：
void printPrime(int n){//判断n是否是质数
        boolean isPrime=true;//是否是质数的标志
        int s=(int)Math.sqrt(n);//对n开根号
        for(int i=s;i>1;i—){//n除以每个比n开根号小比1大的自然数
            if(n%i==0){//如果有能被整除的，则不是质数
                isPrime=false;
            }
        }
        if(isPrime){//如果是质数，则打印出来
            System.out.print(n+" ");
            primeNumber++;//记录质数的个数
            if(primeNumber%10==0)//输出10个质数后换行
                System.out.println();
        }
}
3、筛法求质数，效率最高，但会比较浪费内存
　　首先建立一个boolean类型的数组，用来存储你要判断某个范围内自然数中的质数，例如，你要输出小于200的质数，你需要建立一个大小为201（建立201个存储位置是为了让数组位置与其大小相同）的boolean数组，初始化为true。
　　其次用第二种方法求的第一个质数（在此是2），然后将是2的倍数的数全置为false（2除外），即2、4、6、8……位置上置为false。然后是3的倍数的全置为false（3除外），一直到14（14是200的开平方），这样的话把不是质数的位置上置为false了，剩下的全是质数了，挑着是true的打印出来就行了。
对应代码是：
boolean[] printPrime(int range){
        boolean[] isPrime=new boolean[range+1];
        isPrime[1]=false;//1不是质数
        Arrays.fill(isPrime, 2,range+1,true);//全置为true（大于等于2的位置上）
        int n=(int)Math.sqrt(range);//对range开根号
        for(int i=2;i<=n;i++)//注意需要小于等于n
            if(isPrime[i])//查看是不是已经置false过了
                for(int j=i;j*i<range;j++)//将是i倍数的位置置为false
                    isPrime[j*i]=false;
        return isPrime;//返回一个boolean数组

　　质数定义：只能被1或者自身整除的自然数（不包括1），称为质数。
　　利用它的定义可以循环判断该数除以比它小的每个自然数（大于1），如果有能被它整除的，则它就不是质数。
对应代码是：
void printPrime(int n){//判断n是否是质数
        boolean isPrime=true;//是否是质数的标志
        for(int i=n-1;i>1;i—){//n除以每个比n小比1大的自然数
            if(n%i==0){//如果有能被整除的，则不是质数
                isPrime=false;
            }
        }
        if(isPrime){//如果是质数，则打印出来
            System.out.print(n+" ");
            primeNumber++;//记录质数的个数
            if(primeNumber%10==0)//输出10个质数后换行
                System.out.println();
        }
}
2、利用一个定理——如果一个数是合数，那么它的最小质因数肯定小于等于他的平方根。例如：50，最小质因数是2，2<50的开根号
再比如：15，最小质因数是3，3<15的开根号
　　合数是与质数相对应的自然数。一个大于1的自然数如果它不是合数，则它是质数。
　　上面的定理是说，如果一个数能被它的最小质因数整除的话，那它肯定是合数，即不是质数。所以判断一个数是否是质数，只需判断它是否能被小于它开跟后后的所有数整除，这样做的运算就会少了很多，因此效率也高了很多。
对应代码是：
void printPrime(int n){//判断n是否是质数
        boolean isPrime=true;//是否是质数的标志
        int s=(int)Math.sqrt(n);//对n开根号
        for(int i=s;i>1;i—){//n除以每个比n开根号小比1大的自然数
            if(n%i==0){//如果有能被整除的，则不是质数
                isPrime=false;
            }
        }
        if(isPrime){//如果是质数，则打印出来
            System.out.print(n+" ");
            primeNumber++;//记录质数的个数
            if(primeNumber%10==0)//输出10个质数后换行
                System.out.println();
        }
}
3、筛法求质数，效率最高，但会比较浪费内存
　　首先建立一个boolean类型的数组，用来存储你要判断某个范围内自然数中的质数，例如，你要输出小于200的质数，你需要建立一个大小为201（建立201个存储位置是为了让数组位置与其大小相同）的boolean数组，初始化为true。
　　其次用第二种方法求的第一个质数（在此是2），然后将是2的倍数的数全置为false（2除外），即2、4、6、8……位置上置为false。然后是3的倍数的全置为false（3除外），一直到14（14是200的开平方），这样的话把不是质数的位置上置为false了，剩下的全是质数了，挑着是true的打印出来就行了。
对应代码是：
boolean[] printPrime(int range){
        boolean[] isPrime=new boolean[range+1];
        isPrime[1]=false;//1不是质数
        Arrays.fill(isPrime, 2,range+1,true);//全置为true（大于等于2的位置上）
        int n=(int)Math.sqrt(range);//对range开根号
        for(int i=2;i<=n;i++)//注意需要小于等于n
            if(isPrime[i])//查看是不是已经置false过了
                for(int j=i;j*i<range;j++)//将是i倍数的位置置为false
                    isPrime[j*i]=false;
        return isPrime;//返回一个boolean数组

}

http://blog.csdn.net/angelazy/article/details/45561885

题目描述

Count the number of prime numbers less than a non-negative number, n。

本题要求我们求出小于n的数中共有多少个质数。相信大部分同学在刚开始学习C语言的时候估计都写过判断一个数为质数的程序。一般的思路为：

bool isPrime(int num)   {
    int s = sqrt(num) + 1;
    for( int i = 3; i != s; ++i)   {
        if (num mode i == 0)
            return false;
    }
    return true;
}

但是若对小于n的每一个数进行上述计算，会重复很多次，效率很低。

这里LeetCode给出了两个提示链接：

• How Many Primes Are There?
• Sieve of Eratosthenes

第一个链接给出了本题答案的近似估计公式，第二个介绍了一种很好的算法。这里介绍一下第二种思路，想了解得更全面的同学，请猛戳上面的第二个链接。

• 我们知道2是最小的质数，那么2的倍数均不为质数（因为它们可以分解为一个数*2），所以我们可以将小于n的数中2的倍数，全部排除掉。
• 排除掉2的整数倍后，剩下的数中大于2的最小的数就是下一个质数，也就是3.
• 同样我们可以排除掉小于n的数中3的整数倍的数，得到下一个质数为5.

根据上述思路处理，直到获得所有的质数为止。

这里还可以进行一个优化，即对于质数 p，排除掉p的整数倍后，剩下的元素中满足  p<k<p∗p 的元素k均为质数。这里简单证明一下：

• 每个非质数均可以分解为若干个（ >2 ，否则 k 本身为质数）质数的乘积：  k=p1∗p2∗⋯∗pm ；
• 对于满足 p<k<p∗p 的元素来说，如果 k 不为质数，则 k 可以分解为 k=p1∗p2∗⋯∗pm ，其中必然有一个质数满足  pi<p ；
• 这里用反证法证明。若 k=p1∗p2∗⋯∗pm 中每一个质数均 pi>p ；则有 k>p∗p ，超出限定的条件 p<k<p∗p ，所以该非质数已经在前面的处理过程中排除掉了。

参考下图可以更容易了解（这里盗一下wiki的图~~） 

代码

本题使用动态数组表示小于n的每个元素是否为质数，效率比较高，下面的代码时间为50+ms， 我试过用vector时间一下子到了800+ms，太可怕了。

class Solution {
public:

    int countPrimes(int n) {
        if (n <= 2) return 0;
        bool *p = new bool[n];
        memset(p, true, sizeof(bool) * n);
        for (int i = 2; i * i < n; i++)
        {
            if (p[i])
            {
                for (int j = 2; j * i < n; j++)
                    p[i * j] = false;
            }
        }

        int cnt = 0;
        for (int i = 2; i != n; i++)
            if (p[i])   cnt++;
        delete[] p;
        return cnt;
    }
};