有人能解释一下下面的素数生成方法吗？

Question

我想下面的方法使用Sieve of Eratosthenes （包含 - 排除算法）来生成最多给定数量的素数。 我特别不明白的是，为什么它清除(j/2)位置上设置的位。 是否遵循了特定的规则？ BitSet包含在位置x处设置的位，该数字是素数或是复合数。 所以，我无法跟踪发生的事情。

public static List<Integer> generatePrimes(int max) {
        BitSet primeSet = new BitSet(max / 2);
        primeSet.set(1, max / 2);
        int limit = (int) Math.sqrt(max);
        for (int i = 3; i <= limit; i += 2) {
            if (!primeSet.get(i / 2)) continue;
            for (int j = i * i; j < max; j += i * 2)
                primeSet.clear(j / 2);

        }

        List<Integer> listOfPrimes = new ArrayList<>();
        listOfPrimes.add(2);
        for (int i = primeSet.nextSetBit(0); i >= 0; i = primeSet.nextSetBit(i + 1)) {
            listOfPrimes.add(i * 2 + 1);
        }
        return listOfPrimes;
    }

Answer 1

似乎算法试图通过使primeSet 仅表示奇数来节省内存。 因此，重复乘法和除以2。

涉及primeSet.clear()的循环只是将i每个倍数标记为复合。

Answer 2

public static List<Integer> generatePrimes(int max) {

 BitSet primeSet = new BitSet(max / 2);  // host the numbers i up to max/2
 primeSet.set(1, max / 2);               // representing the odds (2i+1)
 int limit = (int) Math.sqrt(max);       //                      below max
 for (int i = 3; i <= limit; i += 2)        // enumerate odds in range 
 {                                          //       3 .. sqrt(max)
     if (!primeSet.get(i / 2)) continue;    // i=2k+1, i/2==(2k+1)/2== k
                                            // (here i is value, k is index)
     for (int j = i * i; j < max; j += i * 2)  // j=i*i is the first multiple
         primeSet.clear(j / 2);        // of i, where the marking off begins
 }                                     //  with step 2*i: 3: 9,6,15,21,...
                                       //                 7: 49,63,77,91,...
 List<Integer> listOfPrimes = new ArrayList<>();
 listOfPrimes.add(2);                     // 2 is known to be prime a priori
 for (int i = primeSet.nextSetBit(0);     // starting with first set bit in
                                          //                 BitSet primeSet,
          i >= 0;                         // 1: until the end of primeSet  
          i = primeSet.nextSetBit(i + 1)  // 3: and go to next set bit
          ) {
     listOfPrimes.add(i * 2 + 1);         // 2: add 2i+1 to the list of primes,
 }                                        // (here i is index)
 return listOfPrimes;
}

th number, starting from n ² , as apparently one Rev. Samuel Horsley FRS knew back in 1772 . 作为筛子的一部分，我们必须标记从9开始的每个第三个数字，并且通常每个第个数字，从n ²开始，显然是一个牧师Samuel Horsley FRS在1772年知道 。

沿着列表计算是低效的 - 筛选效率的关键是通过地址直接访问内存。 这里数字数字中的数字地址只是数字的值本身（ 值和地址的这种混合也是各种整数排序方法效率的关键）。

要直接计算每个第3个奇数，我们必须将6添加到前一个以获得下一个。 对于每个第5个，我们添加10个，每个i th - 2*i 。

---

顺便提一下，这个代码可以略微改进。 对于它们之间的距离2*i处的数字，集合中的索引将位于距离i 。 无需一直删除2，只需计算起始索引和i增量即可。

---

编辑：该代码等效于以下伪代码：

defn primes(max):
  sieve := makeArray(3,5,7 ... max, True)
  for p from 3 to sqrt(max) step 2:
    if sieve[p]:
        for i from p * p to max step 2*p:
            sieve[i] := False
  primes = {2} + {all i in (3,5,7, ... max) such that sieve[i] is True}

Answer 3

除2之外的所有偶数都不是素数，因此不需要迭代它们。

Answer 4

primeset的位表示数字2x + 1，其中x是位集的索引。 因此，当你的primeset包含{1,2,3,5,6,8,9,11,14}时，它们代表数字{3,5,7,11,13,17,19,23,29}。

如果你对素数编程感兴趣，我谦虚地在我的博客上推荐这篇文章 。 除此之外，它解释了Eratosthenes的Sieve以及导致你悲伤的计算。

编辑：添加简单的Eratosthenes筛选，如评论中所述。

function primes(n)
    sieve := makeArray(2..n, True)
    for p from 2 to n step 1
        if sieve[p]
            output p
            for i from p * p to n step p
                sieve[i] := False