筛选大于 int 的 Eratosthenes

Question

我想找出 100 亿以下的所有素数。这是 int 可以容纳的 5 倍（这是数组的限制，无论类型如何）。尝试一次分配超过 12 亿个会导致堆空间不足错误。我尝试使用 List 而不是布尔数组，但 arrayLists 的 set element 方法只能索引到 int。让我烦恼的是，很快进入筛子的元素少于整数个没有被划掉。一种应该有效的方法是创建一个由 10 个数组组成的分区并将它们粉碎在一起......但这会很丑陋。如果您对解决此问题的优雅方法有任何建议，请告诉我。 （除了使用 Python 哈哈）。我已经有一个 n^2/2 蛮力实现，但这需要很长时间才能运行，所以我真的想尽可能快地解决这个问题。我的高达 12 亿的 Sieve 实现如下：

public class SieveEratosthenes {
private boolean[] nums;
public static void main(String[] args) {
    int n = 1000000;
    SieveEratosthenes s = new SieveEratosthenes(n);
    for(int i=0;i<s.nums.length;i++){
        if(s.nums[i]){
            System.out.println(i);
        }
    }
}

public SieveEratosthenes(int max){
    sieve(max);
}

private boolean[] sieve(int max){
    nums = new boolean[max+1];
    initFlags();
    for(int i=2;i*i<max;i++){
        for(int j=i*i;j<=max;j+=i){//cross off non-primes
            nums[j]=false;
        }
    }
    return nums;
}
private void initFlags(){
    if(nums != null&&nums.length>1){
        nums[0]=false;
        nums[1]=false;
        nums[2]=true;
    }
    for(int i=3;i<nums.length;i++){
        nums[i]=true;
    }
}

public List<Long> sieveToList(){
    List<Long> sieveList = new ArrayList();
    for(int i=0;i<nums.length;i++){
        if(nums[i]){
            sieveList.add((long)i);
        }
    }
    return sieveList;
}

Answer 1

这是您可以使用的一种方法：

• 使用 10^7 整数或任何适合您的大小的筛子。
• 然后，对于 sieve 的每个实现，最后，将所有计算的素数保存在您熟悉的任何数据结构中（ArrayList 可以）。
• 现在，这样做 1000 次，使用循环（当然）每次，您的筛子都会计算下一个 10^7 范围内的素数。因此，在第一次迭代中，将计算 0-10^7 的所有素数。然后，从 10^7+1 到 2*10^7 等等。

PS：如果你想要代码，我会为你做，但我建议你尝试一次。我可能错了，但我认为这种方法就是他们所说的segmented sieve。

Answer 2

您可能不应该为此使用数组。正如你所说，它们不太适合非常大的集合。该算法的一个合理近似是在您检查每个素数时“划掉”，通过测试它是任何先前素数的倍数。这个性能我还没分析。

class Sieve {
    private long current = 2;
    private final List<Long> primes = new ArrayList<>();

    public long nextPrime() {
        while (primes.stream().anyMatch(p -> current % p == 0))
            current++;
        primes.add(current);
        return current;
    }
}

Answer 3

如果内存不是问题，请继续使用数组，因为它更快。如果内存成为问题，我建议研究一下 BitSets。

虽然 Java 数据结构被限制（据我所知）最大 int 大小约为 20 亿，但您可以创建自己的数据结构。一个非常简单的解决方案是创建一个类，将您请求的大小拆分为给定最大 int 长度的几个数组或位集，然后通过您输入的长索引输入自动访问它们。我希望这是有道理的。如果您有任何问题，请告诉我！