为了计算第n个素数，我知道两个主要的变体。

直截了当的方式

也就是说，从找到的所有素数开始计数，直到找到所需的n th为止。

这可以通过不同程度的复杂性和效率来完成，并且在概念上有两种不同的实现方式。 首先是

依次测试所有数字的素性

这将通过像

public static int nthPrime(int n) {

int candidate, count;

for(candidate = 2, count = 0; count < n; ++candidate) {

if (isPrime(candidate)) {

++count;

}

}

// The candidate has been incremented once after the count reached n

return candidate-1;

}

而决定效率的有趣部分是isPrime函数。

质数检查的一种明显方法是，将质数定义为大于1的数，该数只能被1以及我们在学校学到的1整除。

审判师

将定义直接转换为代码是

private static boolean isPrime(int n) {

for(int i = 2; i < n; ++i) {

if (n % i == 0) {

// We are naive, but not stupid, if

// the number has a divisor other

// than 1 or itself, we return immediately.

return false;

}

}

return true;

}

但是，您很快就会发现，如果尝试使用它，它的简单性就会伴随缓慢。 通过该素数测试，您可以在几毫秒内找到第1000 个素数(7919)(在我的计算机上大约为20)，但是找到10000 个素数104729，则需要几秒钟(〜2.4s)，第100000 个素数，1299709 ，几分钟(约5分钟)，百万分之一的素数15485863，大约需要八个半小时，而千万分之一的素数，179424673，则需要数周，依此类推。 运行时复杂度比平方-Θ(n²* log n)还差。

因此，我们希望加快原始性测试的速度。 许多人采取的步骤是意识到n的除数( n本身除外)最多为n/2 。 如果我们使用该事实并让试验除法循环仅运行到n/2而不是n-1 ，算法的运行时间将如何变化？ 对于复合数字，循环下限不变。 对于素数，试行次数减少了一半，因此总体而言，运行时间应减少一个小于2的因数。如果尝试一下，您会发现运行时间几乎精确地减少了一半，因此几乎所有尽管有更多的复合词而不是素数，但是花时间验证素数的素数。

现在，如果我们想找到百万分之一的质数，那并没有太大帮助，所以我们必须做得更好。 尝试进一步减小循环限制，让我们看看实际需要n/2的上限是多少。 如果n/2是的除数n ，然后n/2是整数，换句话说， n是由2整除但随后的循环不晃过2，所以它永远不会(除了n = 4 )达到n/2 。 太好了，那么n的下一个最大除数是多少？ 为什么，当然是n/3 。 但是，如果n/3是整数，则n/3只能是n的因数，换句话说，如果n被3整除，则循环将在3(或之前的2)退出，并且永远不会达到n/3 (除对于n = 9 )。 下一个最大的除数...

等一下 我们有2 n/2和3 n/3 。 n的除数成对出现。

如果我们考虑到一对(d, n/d)的相应的除数n ，无论是d = n/d ，即d = √n ，或它们中的一个，说d ，比其他小。 但是然后d*d < d*(n/d) = n和d < √n 。 n每对对应的除数包含(至少)一个不超过√n除数。

如果 n 为合成，则其最小平凡因数不超过 √n 。

因此，我们可以将循环限制降低到√n ，从而降低了算法的运行时复杂度。 现在应该是Θ(n 1.5 *√(log n))，但是从经验上看，它似乎可以更好地扩展-但是，没有足够的数据可以从经验结果中得出可靠的结论。

这样就可以在大约16秒内找到百万分之一的质数，在不到9分钟的时间内找到百万分之一的质数，并且在大约四个半小时内可以找到百万分之一的质数。 这仍然很慢，但是与十年左右的时间相去甚远，这需要天真的审判部门。

由于存在素数的平方和两个近似素数的乘积，例如323 = 17 * 19，因此我们不能将试算除法循环的极限降低到√n以下。 因此，在保持试验划分的同时，我们现在必须寻找其他方法来改进算法。

一个容易看出的事情是，除2以外的其他素数都不是偶数，因此在处理完2之后我们只需要检查奇数即可。但是，这没有太大的区别，因为偶数是最便宜的。复合-并且仍然花费大量时间来验证素数的素性。 但是，如果将偶数视为候选除数，则会发现如果n被偶数整除，则n本身必须是偶数，因此(除2外)在除以任何更大的偶数之前将被识别为合成数尝试大于2。 因此，在算法中发生的所有大于2的偶数除法都必须留下一个非零的余数。 因此，我们可以忽略这些除法，仅检查2的除数，并检查3到√n的奇数。 这将确定一个数字为质数或复合数所需的除法数减半(不是很精确)，因此将运行时间减半。 这是一个好的开始，但是我们可以做得更好吗？

另一个大数字家族是3的倍数。我们执行的每三等分都是3的倍数，但是如果n被其中一个整除，那么它也可以被3整除，因此不能除以9、15、21 ，...，我们在算法中执行的运算将永远保留0的余数。那么，如何跳过这些除法呢？ 好吧，不能被2或3整除的数字恰好是形式6*k ± 1 。 从5开始(因为我们只对大于1的数字感兴趣)，所以它们是5、7、11、13、17、19，...，从一个步到另一个步在2和4之间交替，即很容易，所以我们可以使用

private static boolean isPrime(int n) {

if (n % 2 == 0) return n == 2;

if (n % 3 == 0) return n == 3;

int step = 4, m = (int)Math.sqrt(n) + 1;

for(int i = 5; i < m; step = 6-step, i += step) {

if (n % i == 0) {

return false;

}

}

return true;

}

这使我们又提高了(将近)1.5倍，因此我们需要大约一个半小时才能达到百万分之一的质数。

如果我们继续这条路线，则下一步是消除5的倍数。以2、3和5为素数的数字是形式的数字

30*k + 1, 30*k + 7, 30*k + 11, 30*k + 13, 30*k + 17, 30*k + 19, 30*k + 23, 30*k + 29

因此我们只需要将每三十个数字除以八(再加上三个最小的质数)即可。 从一个步骤到下一个步骤(从7开始)循环到4、2、4、2、4、6、2、6。这仍然很容易实现，并且可以将速度提高1.25倍(减去更复杂的代码)。 更进一步，将消除7的倍数，在每210个数字中除48个以除以11(480/2310)，13(5760/30030)，依此类推。 消除了倍数的每个素数p产生(几乎) p/(p-1)的加速，因此返回值降低，而成本(代码复杂度，用于步骤的查找表的空间)随每个素数而增加。

通常，在消除了六个或七个素数(甚至更少)的倍数之后，很快就会停止。 但是，在这里，我们可以进行到最后，当所有质数的倍数都被消除并且仅保留质数作为候选除数时。 由于我们按顺序查找所有素数，因此在需要将每个素数用作候选除数之前将其找到，然后可以将其存储以备将来使用。 这将算法复杂度降低到-如果我没有算错的话-O(n 1.5 /√(log n))。 以用于存储素数的空间使用为代价。

随着审判庭，这是好得不能再好，你必须尝试所有素数鸿沟√n或第一分n确定的素性n 。 在大约半小时内找到了百万分之一的质数。

那怎么样

快速素数测试

质数具有其他的数论性质，而不是通常没有复数的平凡除数。 如果可以快速检查这些属性，它们可以构成概率或确定性素数测试的基础。 该原型财产与皮埃尔·德·费马的名字，谁，在17 世纪初，发现相关

如果p是一个素数，则p是(为p-A)的所有除数a 。

这就是费马的所谓“小定理”，用等价的形式表示

设p是一个素数及a不整除p 。 然后p除以p- 1-1。

大多数广泛的快速素数测试(例如Miller-Rabin)的基础以及其变体或类似物的出现甚至更多(例如Lucas-Selfridge)。

因此，如果我们想知道一个不太小的奇数n是否是质数(通过试验除法有效地处理了偶数和小数)，我们可以选择a不是n的倍数的数字a (> 1)。回到图2，检查n是否除以n-1-1 。由于n-1变得很大，所以最有效的方法是检查a^(n-1) ≡ 1 (mod n) ，即通过模幂。 如果这种一致性不成立，我们就知道n是复合的。 但是，如果成立，我们不能得出n是素数的结论，例如2^340 ≡ 1 (mod 341) ，但是341 = 11 * 31是合成的。 使得a^(n-1) ≡ 1 (mod n)复合数n被称为以a为底a Fermat伪素数。

但是这种情况很少见。 给定任何a > 1底数，尽管有无限数量的Fermat伪素数作为基数a ，但它们比实际的素数少得多。 例如，在100000以下，只有78个base-2 Fermat伪素数和76 base-3 Fermat伪素数，但是9592个素数。 因此，如果选择任意奇数n > 1和任意基数a > 1并找到a^(n-1) ≡ 1 (mod n) ，则很有可能n实际上是素数。

但是，我们处的情况略有不同，我们给n只能选择a 。 那么，对于一个奇数复合n ，对于a ， 1 < a < n-1 a^(n-1) ≡ 1 (mod n)容纳多少a，呢？ 不幸的是，合数-卡迈克尔数-使得一致性适用于每 a互质n 。 这意味着要通过费马检验将Carmichael数识别为复合数，我们必须选择一个n是n素数之一的倍数的基数-这样的倍数可能不多。

但是我们可以加强费马测试，以便更可靠地检测复合材料。 如果p是奇质数，则写p-1 = 2*m 。 然后，如果0 < a < p ，

a^(p-1) - 1 = (a^m + 1) * (a^m - 1)

和p精确地除以两个因子之一(两个因子相差2，因此它们的最大公约数为1或2)。 如果m是偶数，我们可以用相同的方式分解a^m - 1 。 继续，如果p-1 = 2^s * k且k奇数，则写

a^(p-1) - 1 = (a^(2^(s-1)*k) + 1) * (a^(2^(s-2)*k) + 1) * ... * (a^k + 1) * (a^k - 1)

然后p精确地除以因子之一。 这引起了强大的费马测试，

令n > 2为奇数。 用k奇数写n-1 = 2^s * k 。 给出的任何a具有1 < a < n-1如果

a^k ≡ 1 (mod n)或

对于任何0 <= j < s j ， a^((2^j)*k) ≡ -1 (mod n)

然后n为碱基的强(费马)可能素 a 。 一种复合强碱a (费马)可能素被称为对于基部的强(费马)伪素a 。 强Fermat伪启动子甚至比普通Fermat伪启动子稀有，低于1000000，有78498个启动子，245个base-2 Fermat伪启动子和46个base-2强Fermat伪启动子。 更重要的是，对于任何奇数复合n ，最多存在(n-9)/4碱基1 < a < n-1 ，其中n是强费马伪素数。

因此，如果n是一个奇数复合，则n通过k强Fermat检验并在1和n-1 (专有范围)之间随机选择的碱基的概率小于1/4^k 。

强大的Fermat检验需要执行O(log n)个步骤，每个步骤都涉及一个数字与O(log n)位的一或两个乘法，因此复杂度为O((log n)^ 3)天真的乘法[对于n ，更复杂的乘法算法可能值得]。

Miller-Rabin检验是具有随机选择碱基的k倍强Fermat检验。 这是一个概率测试，但是对于足够小的边界，已知碱基的简短组合会给出确定的结果。

强大的Fermat测试是确定性APRCL测试的一部分。

建议在进行此类测试之前先进行前几个小素数的试验划分，因为划分相对便宜，并且淘汰了大多数复合材料。

对于找到第n 个素数的问题，在对所有数进行素数测试都是可行的范围内，存在已知的基数组合，这些基数使多重强Fermat检验正确，因此可以给出更快的-O(n *(log n) 4 )-算法。

对于n < 2^32 ，基数2、7和61足以验证素数。 使用它，大约六分钟内即可找到亿万个质数。

通过主要除数(Eratosthenes筛)消除复合材料

除了顺序研究数字并检查每个数字是否都是从头算起，还可以将整个相关数字视为一个整体，并一次性消除给定素数的倍数。 这被称为Eratosthenes筛网：

查找不超过N的质数

列出从2到N的所有数字

对于从2到N每一个k ：如果k尚未被取整，则为质数； 将k所有倍数k

质数是列表中没有被舍去的数字。

该算法与试验划分从根本上不同，尽管两者均直接使用素数的可除性表征，这与Fermat检验和使用素数其他属性的类似测试形成对比。

在试验除法中，每个数n与不超过√n和n的最小除数的所有素数配对。 由于大多数复合材料的除数很小，因此平均而言，检测复合材料很便宜。 但是测试素数是昂贵的，因为√n以下有很多素数。 尽管合成词的数量比素数多，但素数的测试成本如此之高，以至于它完全支配了整个运行时间，并使试验划分成为一种相对较慢的算法。 对于所有小于N数字，进行除法运算需要O(N 1.5 /(log N)²)。

在筛子中，每个复合n与其所有主除数配对，但仅与这些除数配对。 因此，质数是便宜的数字，它们一次只能被查看，而复合材料则更昂贵，它们被多次划掉。 可能有人认为，由于筛子包含的“昂贵”数字比“便宜”的数字多，因此总体而言是一种不好的算法。 但是，一个复合数没有很多不同的素数除数n的不同素数除数的数量由log n ，但是通常它要小得多，数字<= n的不同素数除数的平均值是log log n因此，即使筛子上的“昂贵”数字平均也不会比试验划分的“便宜”数字昂贵(或几乎没有)。

筛选多达N ，对于每个素数p ，都有Θ(N/p)倍数要舍去，因此Θ(∑ (N/p)) = Θ(N * log (log N))的总数为Θ(∑ (N/p)) = Θ(N * log (log N)) 。 与使用更快的素数测试的试验划分或顺序测试相比，这产生了更快的算法来查找素数N

但是，筛子有一个缺点，它使用O(N)内存。 (但是使用分段筛，可以在不增加时间复杂度的情况下将其减小为O(√N) 。)

为了找到第n 个素数而不是最高达N的素数，还存在一个问题，即事先不知道筛子应该到达多远。

后者可以使用素数定理求解。 PNT说

π(x) ~ x/log x (equivalently: lim π(x)*log x/x = 1),

其中π(x)是不超过x的素数(此处和以下， log必须是自然对数，因为算法复杂度，选择对数的底数并不重要)。 由此可以得出p(n) ~ n*log n ，其中p(n)是第n 个素数，并且从更深入的分析中可以知道p(n)上限很合适

n*(log n + log (log n) - 1) < p(n) < n*(log n + log (log n)), for n >= 6.

因此，可以将其用作筛分极限，不会超过目标。

O(N)空间要求可以通过使用分段筛来解决。 然后可以记录O(√N / log N)内存消耗低于√N的素数，并使用长度增加的段(当筛子接近N时使用O(√N))。

如上所述，对算法进行了一些简单的改进：

开始在p²处舍弃p倍数，而不是在2*p

从筛子中消除偶数

从筛子上消除更多小质数的倍数

这些方法都不能降低算法的复杂性，但是它们都可以极大地减少常数因子(与试验划分一样，对于较大的p ，消除p的倍数会导致较小的加速，而与较小的p相比，则增加了代码复杂性)。

使用前两个改进产生

// Entry k in the array represents the number 2*k+3, so we have to do

// a bit of arithmetic to get the indices right.

public static int nthPrime(int n) {

if (n < 2) return 2;

if (n == 2) return 3;

int limit, root, count = 1;

limit = (int)(n*(Math.log(n) + Math.log(Math.log(n)))) + 3;

root = (int)Math.sqrt(limit) + 1;

limit = (limit-1)/2;

root = root/2 - 1;

boolean[] sieve = new boolean[limit];

for(int i = 0; i < root; ++i) {

if (!sieve[i]) {

++count;

for(int j = 2*i*(i+3)+3, p = 2*i+3; j < limit; j += p) {

sieve[j] = true;

}

}

}

int p;

for(p = root; count < n; ++p) {

if (!sieve[p]) {

++count;

}

}

return 2*p+1;

}

在大约18秒内找到亿万个质数2038074743。 通过存储打包的标志(每个标志一位)而不是boolean s，可以将这段时间减少到大约15秒(此处为YMMV)，因为减少的内存使用量可以提供更好的缓存位置。

打包标志，也消除3的倍数，并使用位旋转来更快地进行计数，

// Count number of set bits in an int

public static int popCount(int n) {

n -= (n >>> 1) & 0x55555555;

n = ((n >>> 2) & 0x33333333) + (n & 0x33333333);

n = ((n >> 4) & 0x0F0F0F0F) + (n & 0x0F0F0F0F);

return (n * 0x01010101) >> 24;

}

// Speed up counting by counting the primes per

// array slot and not individually. This yields

// another factor of about 1.24 or so.

public static int nthPrime(int n) {

if (n < 2) return 2;

if (n == 2) return 3;

if (n == 3) return 5;

int limit, root, count = 2;

limit = (int)(n*(Math.log(n) + Math.log(Math.log(n)))) + 3;

root = (int)Math.sqrt(limit);

switch(limit%6) {

case 0:

limit = 2*(limit/6) - 1;

break;

case 5:

limit = 2*(limit/6) + 1;

break;

default:

limit = 2*(limit/6);

}

switch(root%6) {

case 0:

root = 2*(root/6) - 1;

break;

case 5:

root = 2*(root/6) + 1;

break;

default:

root = 2*(root/6);

}

int dim = (limit+31) >> 5;

int[] sieve = new int[dim];

for(int i = 0; i < root; ++i) {

if ((sieve[i >> 5] & (1 << (i&31))) == 0) {

int start, s1, s2;

if ((i & 1) == 1) {

start = i*(3*i+8)+4;

s1 = 4*i+5;

s2 = 2*i+3;

} else {

start = i*(3*i+10)+7;

s1 = 2*i+3;

s2 = 4*i+7;

}

for(int j = start; j < limit; j += s2) {

sieve[j >> 5] |= 1 << (j&31);

j += s1;

if (j >= limit) break;

sieve[j >> 5] |= 1 << (j&31);

}

}

}

int i;

for(i = 0; count < n; ++i) {

count += popCount(~sieve[i]);

}

--i;

int mask = ~sieve[i];

int p;

for(p = 31; count >= n; --p) {

count -= (mask >> p) & 1;

}

return 3*(p+(i<<5))+7+(p&1);

}

在大约9秒钟内找到百万分之一的质数，这个时间并不长。

素数筛还有其他类型，特别感兴趣的是Atkin筛，它利用了以下事实：(同质)素数的某些同余类是ℚ的一些二次扩展的代数整数环中的复合。 这里不是扩展数学理论的地方，足以说Atkin筛比Eratosthenes筛具有更低的算法复杂度，因此对于较大的限制较为理想(对于较小的限制，未过度优化的Atkin筛具有更高的开销，因此可能比同等优化的Eratosthenes筛子慢)。 DJ Bernstein的primegen库(用C编写)针对2 32以下的数字进行了优化，并在约1.1秒内找到了亿分之一的质数。

快速方法

如果我们只想找到第n 个素数，那么找到所有较小的素数也没有内在价值。 如果我们可以跳过其中的大多数，则可以节省大量时间和工作。 给定第n 个素数p(n)近似值a(n) ，如果我们有一种快速的方法来计算素数π(a(n))不超过a(n) ，那么我们可以筛选一个小数范围在a(n)之上或之下，以标识a(n)和p(n)之间的少量缺失或过量素数。

我们已经看到了上面p(n)一个容易计算的相当好的近似值，我们可以得出

a(n) = n*(log n + log (log n))

例如。

Meissel-Lehmer方法是一种计算π(x)好方法，它可以在大约O(x^0.7)时间内计算π(x) (确切的复杂度取决于实现方式，由Lagarias，Miller，Odlyzko，Deléglise进行了改进)里瓦特让我们以O(x 2/3 /log²x)时间计算π(x) )。

从简单逼近a(n) ，我们计算e(n) = π(a(n)) - n 。 根据素数定理， a(n)附近的素数密度约为1/log a(n) ，因此我们期望p(n)接近b(n) = a(n) - log a(n)*e(n) ，我们将筛选比log a(n)*e(n) 。 为了使p(n)在筛分范围内更有把握，可以将范围增加2倍，例如，几乎可以肯定该范围足够大。 如果范围似乎过大，可以用更好的近似迭代b(n)代替a(n)计算π(b(n))和f(n) = π((b(n)) - n通常， |f(n)|会比|e(n)|小得多。如果f(n)近似为-e(n) ，则c(n) = (a(n) + b(n)) / 2将是更好的p(n)近似值，只有在极不可能的情况下f(n)非常接近e(n) (而不是非常接近0)，才能找到足够好的p(n)近似值p(n)最终筛选阶段可以在时间上与计算π(a(n))相提并论成为一个问题。

通常，在对初始近似值进行一到两次改进后，要筛分的范围足够小，以使筛分阶段的复杂度为O(n ^ 0.75)或更高。

此方法在不到八秒的时间内找到了亿万个质数，在10秒内找到了10 12个质数，即29996224275833。

tl; dr：找到第n 个素数可以有效地完成，但是您想要的效率越高，涉及的数学越多。

我为这里准备的大多数讨论的算法准备了 Java代码，以防有人想玩弄它们。

¹撇开对过度感兴趣的灵魂的评论：现代数学中使用的质数的定义是不同的，适用于更一般的情况。 如果我们使学校定义包含负数-因此，如果数字既不是1也不是-1且只能被1，-1本身及其负数整除，则它是质数-它定义了(对于整数)当今称为不可约元素但是，对于整数，素数和不可约元素的定义是一致的。