Question

我正在使用Java中的算法来查找所有素数达到一定数量。它应该是对早期方法的改进，具体如下：

public static int[] generatePrimesUpTo(int max)
{
    int[] primes = new int[max];
    primes[0]=2;
    int p = 1;
    for (int i=3;i<max;i+=2)
    {
        if (isPrime(i))
        {
            primes[p]=i;
            p+=1;
        }
    }
    return primes;  
}

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

只检查一个数字N是否可以被一个较小的数字整除，从2开始到以sqrt（N）结束。

现在，新的方法是将N除以较早的算法所得的较小素数。我认为它会加速这个过程，因为它必须做很少的计算。

public static int[] generatePrimes(int num)
{
    int[] primes = new int[num];
    int p = 3;
    primes[0] = 2;
    primes[1] = 3;
    primes[2] = 5;
    boolean prime;
    for (int i=7;i<num;i+=2)
    {
        prime = true;
        for (int j=0;primes[j+1]<(Math.sqrt(i)+1);j++)
        {
            if (i%primes[j]==0)
            {
                prime = false;
                break;
            }
        }
        if (prime)
        {
            primes[p]=i;
            p++;
        }
    }
    return primes;
}

然而，Nmax = 10 ^ 7的速度似乎几乎没有差异。对于Nmax = 10 ^ 8，新的速度提高了20％，但我的计算机在计算旧计算机时更加活跃，我只尝试了10 ^ 8次。

有人能告诉我为什么这种新方法不会那么快吗？或者我可以做些什么来改进算法？

提前致谢！

Answer 1

您应该考虑是否有一种方法可以在比单独检查每个素数快得多的范围内找到所有素数。例如，您将检查许多数字是否可被73整除。但事实是，您可以更快地确定所有可被73整除的数字（它们是73,2 * 73,3 * 73,4 * 73等。）。

顺便说一句：你在循环的每次迭代中计算Math.sqrt（j）。将该计算移出循环可能会使您的代码更快。

Answer 2

你的第二种算法更快。我不知道为什么你只看到20％的改善。以下是我的测试结果，单独实现：

10^6:
First:  00:00:01.0553813   67240405 steps
Second: 00:00:00.2416291   13927398 steps
Sieve:  00:00:00.0269685    3122044 steps

10^7:
First:  00:00:26.4524301 1741210134 steps
Second: 00:00:04.6647486  286144934 steps
Sieve:  00:00:00.3011046   32850047 steps

10^8:
First:  00:12:00.8986644 46474124250 steps
Second: 00:01:43.1543445  6320928466 steps
Sieve:  00:00:03.6146328   342570200 steps

最后一个算法是Sieve of Eratosthenes，这是一个更好的算法。我在C＃中为一个处理器实现了所有这些，前两个基于您的代码，并进行了一些微小的更改，例如测试primes[j]*primes[j] <= i。

我使用的Eratosthenes筛子的实施非常基础，

Boolean[] definitelyComposite = new Boolean[max]; // initialized automatically to false
int p = 0;
for (long i = 2; i < max; i++)
{
    numSteps++;
    if (!definitelyComposite[i])
    {
        primes[p] = i;
        p++;
        for (long j = i * i; j < max; j += i)
        {
            numSteps++;
            definitelyComposite[j] = true;
        }
    }
}

可以改进。例如，除了i为2时，我可以在循环中使用j+= 2*i。

哪个是素数生成算法中最快的？

2 个答案: