实现 Eratosthenes 筛分以生成给定范围之间的质数的Java程序

能被 1 和它本身整除的数，或者一个因数为 1 和这个数本身的数，称为质数。当 n 小于 1000 万左右时，Eratosthenes 筛法是找到所有小于 n 的素数的最有效方法之一。

例子：

Input : from = 1, to = 20
Output: 2 3 5 7 11 13 17 19

Input : from = 4, to = 15
Output: 5 7 11 13

A. 天真的方法：

1. 定义一个名为 isprime(int n) 的函数，它将检查一个数字是否为素数。
2. 运行从“from”到“to”的循环。
3. 在 for 循环中，检查 i 是否为素数，然后打印 i 的值

下面是上述方法的实现：

Java

// Java Program to Generate Prime
// Numbers Between Given Range
class GFG {
    public static boolean isprime(int n)
    {
        if (n == 1)
            return false;
 
        for (int i = 2; i <= Math.sqrt(n); i++)
 
            // Check if a number has factors
            // its not prime and return 0
            if (n % i == 0)
                return false;
       
        // Check if a number dont
        // have any factore
        // its prime and return 1
        return true;
    }
    public static void main(String[] args)
    {
         
        // Suppose we want to print
        // prime no.  from 1 to 20
        int from = 1, to = 20, k = 0;
        for (int i = from; i <= to; i++)
            if (isprime(i))
                System.out.print(" " + i);
    }
}

输出

2 3 5 7 11 13 17 19

时间复杂度： O(n ^3/2 )

B.埃拉托色尼筛：

最初，假设从 0 到 n 的每个数都是素数，将每个数的数组值赋值为 1。之后，通过将数组中的值从 1 改为 0 来剔除每个非素数，最后只打印那些数组值为 1，即素数。

方法：

1. 从用户输入 n
2. 在数组中，每个元素对应填充1
3. 做 a[0]=0 和 a[1]=0 因为我们知道 0,1 不是素数
4. 假设第一个数字 (2) 是质数并去掉 2 的倍数（因为 2 的倍数将是非质数）
5. 继续第 3 步直到平方根（n）
6. 打印包含未删除（或质数）数字的列表。

下面是上述方法的实现：

Java

// Java Program to Implement
// Sieve of eratosthenes
// to Generate Prime Numbers
// Between Given Range
import java.util.*;
class GFG {
 
    public static void main(String[] args)
    {
        int from = 1, to = 20, i;
        boolean[] a = new boolean[to + 1];
        Arrays.fill(a, true);
 
        // 0 and 1 are not prime
        a[0] = false;
        a[1] = false;
        for (i = 2; i <= Math.sqrt(to); i++)
 
            // Check if number is prime
            if (a[i])
                for (int j = i * i; j <= to; j += i) {
                    a[j] = false;
                }
        for (i = from; i <= to; i++) {
 
            // Printing only prime numbers
            if (a[i])
                System.out.print(" " + i);
        }
    }
}

输出

2 3 5 7 11 13 17 19

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