他是怎么求解第 n 个素数的，筛法嘛

题目：给出一个正整数 n ，求解第 n 个素数(即质数);

---

定义（暴力）法

我们判断一个数 n 是不是素数的时候，可以直接通过素数的定义来求，即只能被 1 和 n （自身）整除，否则这个数就不是素数。
代码如下：

public int violence(int n) {
        int num = 0, result = 0;
        for (int i = 2; ; i++) {
            boolean flag = true;
            for (int j = 2; j * j <= i; j++) {
                if (i % j == 0) {
                    flag = false;
                    break;
                }
                result = i;
            }
            if (flag) {
                num++;
            }
            if (n == num) {
                break;
            }
        }
        return result;
    }

时间复杂度：O(n²)

思路：用一个变量 num 记录找到的素数的个数，每找到一个便自增 1 ，只有当它等于我们我们要找到 n 为止，此时返回的结果 result 便是题目需要的第 n 个素数。

---

筛法的引出

但是我们仔细分析便会发现，如果要求的素数的个数过多的时候，这个方法就不太合适了。原因无他：太慢了！！！都是泪(╥╯^╰╥) 。

因此，我们需要一种更高效的方法来求素数，当当当！筛法来了！筛法是一种求质数的方法，就像筛子一样，将我们需要的质数筛选出来；也可以说是，将求质数时大量无效重复的计算筛选出去。这能极大提升算法性能，甚至达到线性水准。这里将介绍两种筛法。

---

埃拉托斯特尼筛法（埃氏筛法)

基本思路：素数的倍数一定不是素数
实现方法：首先初始化一个boolean类型的大数组 flags , 用于标记每个数是否为合数（不是素数的数），如果是，则为 false，反之为true。
先假设所有的数都是素数（ boolean 数组初始化，所有元素都为 false ），从第一个素数 2 开始，把 2 的倍数都标记为合数（置为 true ），一直到大于某个足够大的值 ；然后进行下一趟，找到 2 后面的下一个素数3，进行同样的处理，直到最后，数组中依然为 false 的数即为素数。
此时再从筛选后的数组中查找我们所需要的素数，就快很多了。
话不多说，代码奉上。

public int eratosthenes(int x) {
        int n = 100000000;
        int result = 0;
        boolean[] flags = new boolean[n];
        for (int i = 2; i < n / 2; i++) {
            if (flags[i]) {
                // 合数没有资格参加筛法
                continue;
            }
            for (int k = 2; k <= n / i; k++) {
                if (i * k < n) {
                    flags[i * k] = true;
                }
            }
        }
        int m = 0;
        for (int i = 2; i < n; i++) {
            if (!flags[i]) {
                m++;
                if (m == x) {
                    result = i;
                }
            }
        }
        return result;
    }

时间复杂度：O(nlog(n))

---

欧拉筛

埃氏筛看起来挺不错，去除了很多无效的计算，但是O(nlog(n)) 的时间复杂度遇见超大计算量的情况，性能还是堪忧，那么我们还能优化吗？答案是肯定的。
欧拉筛又称为线性筛，很好理解，就是时间复杂度达到了 O(n) 的水平。那么它是怎么优化的呢？
回顾上面的埃氏筛，我们不难发现，其实还存在一些重复性计算，比如判断 2 的时候将（2 * 3）6筛了一遍，在判断 3 的时候又将（3 * 2）6 筛了一遍。
为了去掉这部分冗余计算，神奇的欧拉筛出现了。
下面是欧拉筛的实现过程。

public int euler(int n) {
        int max = 100000000, k = 0;
        int[] list = new int[n];
        boolean[] booleans = new boolean[max];
        for (int i = 2; ; i++) {
            if (k == n) {
                break;
            }
            if (!booleans[i]) {
                list[k++] = i;
            }
            for (int j = 0; j < k; j++) {
                if (list[j] * i > max) {
                    break;
                }
                booleans[list[j] * i] = true;
                if (i % list[j] == 0) {
                    break;
                }
            }
        }
        return list[k - 1];
    }

基本思想 ：在埃氏筛法的基础上，让每个合数只被它的最小质因子筛选一次，以达到不重复的目的。
相比埃氏筛，欧拉筛多用了一个数组 list 存放所有筛选出来的质数，并进行相关判断，确保所有的合数都是被它的最小质因数所筛去，以此保证每个数只被筛选了一次，要么是素数，要么是合数。

---

给大家运行两个筛法的运行时间比较（IDEA跑的）
这里计算的是第 70W 个素数O(∩_∩)O

我们可以明显感到欧拉线性筛的强大之处，算法的魅力莫过于此，当然也让人头秃到(*^▽*)，哈哈哈！

结语

领域万变，但精神唯一！