高效查找素数

素数：一个数如果只能被1和它本身整除，那么这个数就是素数

第一版：

思路：遍历[2,n)每个数，判断每个数是否是素数，判断素数的思路是一次将该数被从2到num-1整除，如果其中某个数可以整除，直接返回false，说明不是素数，如果返回true，说明是素数，所以count+=1.

/**
     * 统计[2,n)之间有多少个素数
     * @param n
     * @return
     */
    int countPrimes(int n) {
        int count = 0;
        for (int i = 2; i < n; i++) {
            if (isPrime(i)) {
                count++;
            }
        }
        return count;
    }

    /**
     * 判断num是否是素数
     * @param num
     * @return
     */
    private boolean isPrime(int num) {
        for (int i = 2; i < num; i++) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }

        从代码上看出，该写法的时间复杂度为O(n^2)，问题很大。因为在isPrime方法里面计算是否是素数时，出现很多冗余计算

// 如，判断12是否是素数
//12可以通过以下因子相乘得到
12 = 2 x 6
12 = 3 x 4
12 = sqrt(12) x sqrt(12)
12 = 4 x 3
12 = 6 x 2

        换句话说，最多只要遍历sqrt(num)就可以判断num是否是素数，而不是遍历[2,num)，这一步用于对素数计算的优化，因为合数根本不需要循环这么多次，就已经返回false了。另外，还要想到一点，就是素数的倍数肯定不是素数，因此大循环的时候可以修改一下。

第二版：

//==========================第二版============================
//    换种思路，使用一个包括n个元素的数组进行标记
    /**
     * 统计[2,n)之间有多少个素数
     * @param n
     * @return
     */
    int countPrimes2(int n) {
        boolean[] arr = new boolean[n];
        Arrays.fill(arr, true);

        for (int i = 2; i < n; i++) {
            if (isPrime(i)) {
                for (int j = 2 * i; j < n; j += i) { //j相当于2*i，3*i，4*i，...
//                    素数的倍数都被标记为false
                    arr[j] = false;
                }
            }
        }
//        遍历数组，统计素数
        int count = 0;
        for (int i = 2; i < n; i++) {
            if (arr[i]) {
                count++;
            }
        }

        return count;
    }

    /**
     * 判断num是否是素数
     * @param num
     * @return
     */
    private boolean isPrime2(int num) {
        for (int i = 2; i*i < num; i++) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }

        还有一个优化点，就是：

for (int j = 2 * i; j < n; j += i) { //j相当于2*i，3*i，4*i，...
//                    素数的倍数都被标记为false
                    arr[j] = false;
                }

如，当计算i=5时，j会遍历j=10，j=15，但是10和15早就被i=2和i=3时标记过了，所以当i=5时，j应该从5*5开始，即j=i*i。

稍微优化一下，第三版：

int countPrimes2(int n) {
        boolean[] arr = new boolean[n];
        Arrays.fill(arr, true);

        for (int i = 2; i < n; i++) {
            if (isPrime(i)) {
                for (int j = i * i; j < n; j += i) { //j相当于2*i，3*i，4*i，...
//                    素数的倍数都被标记为false
                    arr[j] = false;
                }
            }
        }

这个时间复杂度计算为：

这就是Sieve of Eratosthenes算法。