【Android面试八股文】荣耀面试算法题：输出1到1000中间有多少个素数？

文章目录

一、素数的定义
二、如何判断为质数？
- 2.1 试除法
- - 2.1.1 具体步骤
  - 2.1.2 算法实现
- 2.2 埃拉托斯特尼筛法
- - 2.2.1 原理
  - 2.2.2 具体步骤
  - 2.2.3 算法实现
  - 2.2.4 示例
  - 2.2.5 优点
  - 2.2.6 缺点
三、输出1到1000中间有多少个素数？
- 3.1 试除法
- 3.2 埃拉托斯特尼筛法
- 3.3 两个算法比较

一、素数的定义

素数又称质数。指在一个大于1的自然数中，除了1和此整数自身外，没法被其他自然数整除的数。 换句话说，只有两个正因数（1和自己）的自然数即为素数。
比1大但不是素数的数称为合数。
1和0既非素数也非合数。

二、如何判断为质数？

2.1 试除法

试除法是判断一个数是否是素数的基本方法。

它的基本思路是：

对于一个大于1的整数 n，如果 n 不能被2到 $\sqrt{n}$ 之间的任何整数整除，则 n 是素数。
否则，n 不是素数。

2.1.1 具体步骤

特例处理：如果 n 小于等于1，则 n 不是素数。
处理2和3：2和3是素数，可以直接返回true。
排除偶数：如果 n 是偶数且大于2，则 n 不是素数。
试除：从5开始检查到 $\sqrt{n}$ 的奇数，如果 n 能被其中任何一个数整除，则 n 不是素数。

2.1.2 算法实现

public class PrimeChecker {
    public static void main(String[] args) {
        int number = 29;
        boolean isPrime = isPrime(number);
        System.out.println(number + " 是素数吗？ " + isPrime);
    }

    public static boolean isPrime(int number) {
    	// 首先处理一些特例。如果 number 小于等于1，则返回false。
        if (number <= 1) {
            return false;
        }
        // 如果 number 是2或3，则返回true，因为它们是素数。
        if (number == 2 || number == 3) {
            return true;
        }
        // 如果 number 是偶数且大于2，则返回false。
        if (number % 2 == 0) {
            return false;
        }
        // 计算 number 的平方根，并从5开始检查每个奇数是否能整除 number。
        // 如果能整除，则返回false；否则，最后返回true，表示 number 是素数。
        int sqrt = (int) Math.sqrt(number);
        for (int i = 5; i <= sqrt; i += 2) {
            if (number % i == 0) {
                return false;
            }
        }
        return true;
    }
}

2.2 埃拉托斯特尼筛法

埃拉托斯特尼筛法是一种高效的找出一定范围内所有素数的算法。

它的基本思想是逐步标记掉非素数，最后剩下的就是所有的素数。

2.2.1 原理

初始化数组：创建一个布尔数组 isPrime，长度为要寻找的最大数 n。初始化时，假设所有数都是素数，将所有元素设为 true，除了索引0和1，因为0和1不是素数。
筛除非素数：从数组的第一个素数2开始，将其所有倍数标记为非素数（设为 false）。然后找到下一个未被标记的数（下一个素数），继续将其倍数标记为非素数。重复这个过程，直到处理到 $\sqrt{n}$ 为止。
收集素数：筛选完成后，数组中仍为 true 的索引即为素数。

2.2.2 具体步骤

创建布尔数组 isPrime，长度为 n + 1，所有元素初始化为 true。
将0和1设为非素数（ isPrime[0] = isPrime[1] = false）。
从2开始，将2的所有倍数（除了2本身）标记为非素数。
找到下一个为 true 的数（即下一个素数），将其所有倍数标记为非素数。
重复步骤4，直到到达 $\sqrt{n}$ 。
遍历数组，收集所有仍为 true 的索引，这些索引对应的数即为素数。

2.2.3 算法实现

public class PrimeCount {
    public static void main(String[] args) {
        int number = 1000;
        int count = countOfSuShu(number);
        System.out.println("1到" + number + "之间的素数个数是：" + count);
    }

    public static int countOfSuShu(int number) {
        if(number < 2) return 0;

        boolean[] isPrime = new boolean[number + 1];

        for(int i = 2; i <= number; i++) {
            isPrime[i] = true;
        }

        for(int i = 2; i * i <= number; i++) {
            if(isPrime[i]) {
                for(int j = i * i; j <= number; j += i) {
                    isPrime[j] = false;
                }
            }
        }

        int count = 0;
        for(int i = 2; i <= number; i++) {
            if(isPrime[i]) {
                count++;
            }
        }

        return count;
    }
}

2.2.4 示例

以 number = 30 为例：

初始化：isPrime = [true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true]
将0和1设为非素数：isPrime = [false, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true]
从2开始筛选：
- 2是素数，标记2的倍数：isPrime = [false, false, true, true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, false]
- 3是素数，标记3的倍数：isPrime = [false, false, true, true, false, true, false, true, false, false, false, true, false, true, false, false, false, true, false, true, false, false, false, true, false, true, false, false, false, true, false]
- 4已标记为非素数，跳过。
- 5是素数，标记5的倍数：isPrime = [false, false, true, true, false, true, false, true, false, false, false, true, false, true, false, false, false, true, false, true, false, false, false, true, false, false, false, false, false, true, false]
最终：isPrime 数组中 true 的索引为 [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]，表示2到30之间的素数。

2.2.5 优点

高效：时间复杂度为 O(nlog⁡ log⁡n)，适用于处理较大范围的素数判断。
简洁：逻辑清晰易理解，代码实现简单。

2.2.6 缺点

空间复杂度较高：需要一个长度为 n 的布尔数组，对于内存有限的环境可能不适用。

埃拉托斯特尼筛法是一种经典且高效的找素数算法，特别适用于处理大范围的素数查找任务。

三、输出1到1000中间有多少个素数？

3.1 试除法

public class PrimeCount {
    public static void main(String[] args) {
        int number = 1000;
        int count = countOfPrimes(number);
        System.out.println("1到" + number + "之间的素数个数是：" + count);
    }

    public static int countOfPrimes(int number) {
        int count = 0;
        for (int i = 2; i <= number; i++) {
            if (isPrime(i)) {
                count++;
            }
        }
        return count;
    }

    public static boolean isPrime(int number) {
        if (number <= 1) {
            return false;
        }
        if (number == 2 || number == 3) {
            return true;
        }
        if (number % 2 == 0) {
            return false;
        }
        int sqrt = (int) Math.sqrt(number);
        for (int i = 5; i <= sqrt; i += 2) {
            if (number % i == 0) {
                return false;
            }
        }
        return true;
    }
}

运行结果：

1到1000之间的素数个数是：168

3.2 埃拉托斯特尼筛法

public class PrimeCount {
    public static void main(String[] args) {
        int number = 1000;
        int count = countOfSuShu(number);
        System.out.println("1到" + number + "之间的素数个数是：" + count);
    }

    public static int countOfSuShu(int number) {
        if(number < 2) return 0;

        boolean[] isSuShu = new boolean[number + 1];

        for(int i = 2; i <= number; i++) {
            isSuShu[i] = true;
        }

        for(int i = 2; i * i <= number; i++) {
            if(isSuShu[i]) {
                for(int j = i * i; j <= number; j += i) {
                    isSuShu[j] = false;
                }
            }
        }

        int count = 0;
        for(int i = 2; i <= number; i++) {
            if(isSuShu[i]) {
                count++;
            }
        }

        return count;
    }
}

3.3 两个算法比较

时间复杂度：
- 算法一（试除法）：判断一个数是否是素数的时间复杂度为 O( $\sqrt{n}$ )。因此，遍历所有数的总时间复杂度为O(n $\sqrt{n}$ )。
- 算法二（埃拉托斯特尼筛法）：时间复杂度为O( n log log n）。
效率：
- 算法一：对于每个数都需要进行判断，随着 number 的增大，效率会下降。
- 算法二：通过一次遍历标记所有非素数，提高了整体效率，特别是对大范围内的数进行素数判断时，更为高效。
空间复杂度：
- 算法一：空间复杂度为 O(1)，因为只需常数级别的额外空间。
- 算法二：空间复杂度为 O(n)，因为需要一个布尔数组来标记每个数是否为素数。
结论
- 算法二（埃拉托斯特尼筛法）更优秀，因为它在处理大范围数的素数判断时效率更高。尽管需要更多的空间来存储布尔数组，但其更低的时间复杂度使其在处理1到1000之间的素数个数时，表现更加优越。
- 在实践中，尤其是当需要计算较大范围内的素数时，埃拉托斯特尼筛法通常是首选。