素数算法(Prime Num Algorithm)
素数算法(Prime Num Algorithm)
数学是科学的皇后,而素数可以说是数学最为核心的概念之一。围绕素数产生了很多伟大的故事,最为著名莫过于哥德巴赫猜想、素数定理和黎曼猜想(有趣的是,自牛顿以来的三个最伟大数学家,欧拉、高斯和黎曼,分别跟这些问题有着深刻的渊源)。我写这篇文章不是要探讨和解决这些伟大猜想和定理,而是回归问题本身,用计算机判定一个素数,以及求取特定正整数值下所包含的所有素数。这篇文章,算是自己对素数问题思考的一次总结。
先说一下素数的定义:
素数也叫质数,是只能被
和其本身所能整除的非 正整数。
第一个素数是2
,它也是唯一一个偶素数。100
以内素数列为:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
有了素数的定义,我们通过计算机程序来解决以下问题。
- 给定一个正整数
, 判定该数是否为素数。 - 给定一个正整数
, 求取小于等于该数的所有素数列。 - 给定两个正整数
, ( ), 求取 到 之间其所包含的素数列。 - 从
开始计算大素数。
解决上述问题的核心算法都是埃拉托斯特尼筛法,简称埃氏筛选法。这个方法的内容即每当我们得到一个素数后,我们即将这个素数的所有倍数(
1. 给定一个正整数 , 判定该数是否为素数
1.1 基于全量整除判定的算法
1.1.1 算法
判定一个整数
1.1.2 代码
package com.lunyu.algorithm.math.numberTheory;
import com.google.common.collect.Lists;
import java.util.List;
/**
* 求素数算法
* @author lunyu
* @since 2022/7/14
*/
public class PrimeNumMain {
public static void main(String[] args) {
// 卢卡斯数列
List<Integer> nums = Lists.newArrayList(1, 3, 4, 7, 11, 18, 29, 47, 76, 123);
for (Integer num : nums) {
boolean isPrime = isPrime(num);
System.out.println("整数:" + num + "是否为素数:" + isPrime);
}
}
/**
* 给定一个正整数n, 判定该数是否为素数
*/
private static boolean isPrime(int num){
if (1 >= num){
return false;
}
for (int i = 2; i < num; i++){
if (0 == num % i){
return false;
}
}
return true;
}
}
1.1.3 算法复杂度
时间复杂度 | 空间复杂度 |
---|---|
1.2 基于全量奇数整除判定的算法优化
因为
1.2.1 算法
判定一个整数
- 该数是是否是
。 - 在该数不为
的情形下,该数是否不被 或小于它的非 奇数所整除。
1.2.2 代码
/**
* 经过优化的给定一个正整数n, 判定该数是否为素数
*/
private static boolean isPrimeOptimized1(int num){
if (1 >= num){
return false;
}
// 判定是否等于2
if (2 == num){
return true;
}
// 判定能否被2整除
if (0 == num % 2){
return false;
}
// 判定能否能被小于自身且大于等于3的奇数整除
for (int i = 3; i < num;){
if (0 == num % i){
return false;
}
i += 2;
}
return true;
}
1.2.3 算法复杂度
时间复杂度 | 空间复杂度 |
---|---|
1.3 基于开根号整数整除判定算法优化
实际上,判定一个整数
直观一点,即自然数
这个优化判定是可以证明的。我们来给出证明。
1.3.1 证明
设有正整数
我们用反证法。
假设它是一个合数,那么它一定可以表示成两个非
我们又已知,它不能被其开方后的整数向下取整(
于是,无论是
于是,
为什么
于是,
证毕。
1.3.2 算法
判定一个整数
1.3.3 代码
/**
* 经过优化的给定一个正整数n, 判定该数是否为素数
*/
private static boolean isPrimeOptimized2(int num){
if (1 >= num){
return false;
}
// 整数num开方向下取整
double sqrtFloorNum = Math.floor(Math.sqrt(num));
for (int i = 2; i <= sqrtFloorNum; i++){
if (0 == num % i){
return false;
}
}
return true;
}
1.3.4 算法复杂度
时间复杂度 | 空间复杂度 |
---|---|
1.4 基于开根号奇数整除判定算法优化
我们可以将1.2 基于全量奇数整除判定的算法优化和1.3 基于开根号整数整除判定算法优化结合起来,形成一个更优算法。
1.4.1 算法
判定一个整数
- 该数是是否是
。 - 在该数不为
的情形下,该数是否不被以下数所整除:- 不被
整除, - 不被其开方后的整数向下取整(
)以内(含 )的非 奇数所整除。
- 不被
1.4.2 代码
/**
* 给定一个正整数n, 判定该数是否为素数
*/
private static boolean isPrimeOptimized3(int num){
if (1 >= num){
return false;
}
if (2 == num){
return true;
}
if (0 == num % 2){
return false;
}
// 整数num开方向下取整
double sqrtFloorNum = Math.floor(Math.sqrt(num));
for (int i = 3; i <= sqrtFloorNum;){
if (0 == num % i){
return false;
}
i += 2;
}
return true;
}
1.4.3 算法复杂度
时间复杂度 | 空间复杂度 |
---|---|
2. 给定一个正整数 , 求取小于等于该数的所有素数列
易知,该问题即是上一问题的序列化,也即将上一问题在外层再套一层for
循环,平铺展开后的问题。
于是,我们先给出一个初始算法。
2.1 基于外层全量循环内层全量整除的算法
2.1.1 算法
给定一个正整数
对从
2.1.2 代码
package com.lunyu.algorithm.math.numberTheory;
import java.util.ArrayList;
import java.util.List;
/**
* 求素数算法
* @author lunyu
* @since 2022/7/14
*/
public class PrimeNumMain {
public static void main(String[] args) {
int n = 300;
List<Integer> primeNums = new ArrayList<>();
getPrimeNums(n, primeNums);
// TODO: 结果输出
System.out.println(n + "以内的素数为:");
for (Integer primeNum : primeNums) {
System.out.print(primeNum + " ");
}
}
/**
* 获得n以内(含n)的素数列
* @param n
* @param primeNums
*/
private static void getPrimeNums(int n, List<Integer> primeNums) {
for (int i = 2; i <= n; i++){
boolean isPrime = isPrime(i);
if (isPrime){
primeNums.add(i);
}
}
}
/**
* 给定一个正整数n, 判定该数是否为素数
*/
private static boolean isPrime(int num){
if (1 >= num){
return false;
}
for (int i = 2; i < num; i++){
if (0 == num % i){
return false;
}
}
return true;
}
}
2.1.3 算法复杂度
因为多了外层的一层for
循环,而内层判定一个整数是否为素数的算法我们用的初始算法(isPrime(int num)
),因此其时间复杂度为
而空间复杂度,因为我们有素数列的采集动作,因此这里空间复杂度不是
时间复杂度 | 空间复杂度 |
---|---|
2.2 基于外层全量奇数循环和内层开根号奇数整除判定的算法优化
这里算法优化我们分为2部分,第一部分是判定单个整数是否素数的优化;第2部分,我们对外层循环进行优化。
第一部分,我们取章节1.4 基于开根号奇数整除判定算法优化给出最终优化方案。
第二部分,我们对for
循环内的数据进行一次简单优化。同样易知,for
循环判定的数据也减半。
2.2.1 算法
给定一个正整数
对
如果为素数,我们将该数存储起来得到的素数列。
2.2.2 代码
public static void main(String[] args) {
int n = 300;
List<Integer> primeNums = new ArrayList<>();
getPrimeNumsOptimized1(n, primeNums);
// TODO: 结果输出
System.out.println(n + "以内的素数为:");
for (Integer primeNum : primeNums) {
System.out.print(primeNum + " ");
}
}
/**
* 获得n以内(含n)的素数列
* @param n
* @param primeNums
*/
private static void getPrimeNumsOptimized1(int n, List<Integer> primeNums) {
if (1 >= n){
return;
}
// 如果n >= 2, 则n以内的素数默认含有2
primeNums.add(2);
// 对大于等3的奇数判定
for (int i = 3; i <= n;){
boolean isPrime = isPrimeOptimized3(i);
if (isPrime){
primeNums.add(i);
}
i += 2;
}
}
/**
* 给定一个正整数n, 判定该数是否为素数
*/
private static boolean isPrimeOptimized3(int num){
if (1 >= num){
return false;
}
if (2 == num){
return true;
}
if (0 == num % 2){
return false;
}
// 整数num开方向下取整
double sqrtFloorNum = Math.floor(Math.sqrt(num));
for (int i = 3; i <= sqrtFloorNum;){
if (0 == num % i){
return false;
}
i += 2;
}
return true;
}
这里外循环针对的是大于等于
public static void main(String[] args) {
int n = 300;
List<Integer> primeNums = new ArrayList<>();
getPrimeNumsOptimized1(n, primeNums);
// TODO: 结果输出
System.out.println(n + "以内的素数为:");
for (Integer primeNum : primeNums) {
System.out.print(primeNum + " ");
}
}
/**
* 获得n以内(含n)的素数列
* @param n
* @param primeNums
*/
private static void getPrimeNumsOptimized1(int n, List<Integer> primeNums) {
if (1 >= n){
return;
}
// 如果n >= 2, 则n以内的素数默认含有2
primeNums.add(2);
// 对大于等3的奇数判定
for (int i = 3; i <= n;){
boolean isPrime = isPrimeOptimized3(i);
if (isPrime){
primeNums.add(i);
}
i += 2;
}
}
/**
* 给定一个大于等于3的奇数n, 判定该数是否为素数
*/
private static boolean isPrimeOptimized3(int num){
// 整数num开方向下取整
double sqrtFloorNum = Math.floor(Math.sqrt(num));
for (int i = 3; i <= sqrtFloorNum;){
if (0 == num % i){
return false;
}
i += 2;
}
return true;
}
2.2.3 算法复杂度
易知外层的for
循环其时间复杂度为
空间复杂度不变,仍为
时间复杂度 | 空间复杂度 |
---|---|
2.3 基于外层全量整数和内层开根号奇素数整除判定的算法优化
1.3 基于开根号整数整除判定算法优化中,判定一个整数是否为素数,即判定该数是否不能被其开方后的整数向下取整(
这个地方的判定,我们可以进一步优化为,判定一个整数是否为素数,即判定该数是否不能被其开方后的整数向下取整(
直观一点,即自然数
证明略,同1.3.1 基于开根号整数整除判定算法优化-证明。
有了以上优化点,我们还缺少素数列集合
2.3.1 算法
给定一个正整数
对从
判定是否为素数的法则为,该数能否不被素数列集合
素数列集合
2.3.2 代码
package com.lunyu.algorithm.math.numberTheory;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
/**
* 求素数算法
* @author lunyu
* @since 2022/7/14
*/
public class PrimeNumMain {
public static void main(String[] args) {
int n = 300;
List<Integer> primeNums = new ArrayList<>();
getPrimeNumsOptimized2(n, primeNums);
// TODO: 结果输出
System.out.println(n + "以内的素数为:");
for (Integer primeNum : primeNums) {
System.out.print(primeNum + " ");
}
}
/**
* 获得n以内(含n)的素数列
* @param n
* @param primeNums
*/
private static void getPrimeNumsOptimized2(int n, List<Integer> primeNums) {
if (1 >= n){
return;
}
for (int i = 2; i <= n; i++){
boolean isPrime = isPrimeOptimized4(i, primeNums);
if (isPrime){
primeNums.add(i);
}
}
}
/**
* 判定是否为素数
*/
private static boolean isPrimeOptimized4(int num, List<Integer> primeNums) {
if (1 >= num){
return false;
}
// 整数num开方向下取整
double sqrtFloorNum = Math.floor(Math.sqrt(num));
// 判定能否被素数列整数
for (Integer primeNum : primeNums) {
if (primeNum > sqrtFloorNum){
break;
}
if (0 == num % primeNum){
return false;
}
}
return true;
}
}
这里外循环针对的是大于等于
/**
* 判定是否为素数
*/
private static boolean isPrimeOptimized4(int num, List<Integer> primeNums) {
// 整数num开方向下取整
double sqrtFloorNum = Math.floor(Math.sqrt(num));
for (Integer primeNum : primeNums) {
if (primeNum > sqrtFloorNum){
break;
}
if (0 == num % primeNum){
return false;
}
}
return true;
}
2.3.3 算法复杂度
易知,外层的for
循环其时间复杂度为
获得素数列,其空间复杂度为
时间复杂度 | 空间复杂度 |
---|---|
2.4 基于外层全量奇数和内层开根号全量奇素数整除判定的算法优化
我们可以将2.2 基于外层全量奇数循环和内层开根号奇数整除判定的算法优化和2.3 基于外层全量整数和内层开根号奇素数整除判定的算法优化结合起来,形成一个更优算法。
2.4.1 算法
给定一个正整数
对
如果为素数,我们将该数存储起来得到的素数列。
2.4.2 代码
package com.lunyu.algorithm.math.numberTheory;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
/**
* 求素数算法
* @author lunyu
* @since 2022/7/14
*/
public class PrimeNumMain {
public static void main(String[] args) {
int n = 300;
List<Integer> primeNums = new ArrayList<>();
getPrimeNumsOptimized4(n, primeNums);
// TODO: 结果输出
System.out.println(n + "以内的素数为:");
for (Integer primeNum : primeNums) {
System.out.print(primeNum + " ");
}
}
/**
* 获得n以内(含n)的素数列
* @param n
* @param primeNums
*/
private static void getPrimeNumsOptimized4(int n, List<Integer> primeNums) {
if (1 >= n){
return;
}
// 如果n >= 2, 则n以内的素数默认含有2
primeNums.add(2);
// 对大于等3的奇数判定
for (int i = 3; i <= n;){
boolean isPrime = isPrimeOptimized4(i, primeNums);
if (isPrime){
primeNums.add(i);
}
i += 2;
}
}
/**
* 判定是否为素数
*/
private static boolean isPrimeOptimized4(int num, List<Integer> primeNums) {
// 整数num开方向下取整
double sqrtFloorNum = Math.floor(Math.sqrt(num));
for (Integer primeNum : primeNums) {
if (primeNum > sqrtFloorNum){
break;
}
if (0 == num % primeNum){
return false;
}
}
return true;
}
}
2.4.3 算法复杂度
易知,外层的for
循环其时间复杂度为
获得素数列,其空间复杂度为
时间复杂度 | 空间复杂度 |
---|---|
3. 给定两个正整数 , ( ), 求取 到 之间其所包含的素数列
这里有两种方式可以解决问题:
第一种对
第二种,我们先求出小于等于
3.1 外层逐个判定和内层开根号素数整除判定的算法
为了减少篇幅,这里直接使用1.4 基于开根号奇数整除判定算法优化中的算法,而不从头开始逐步优化。
3.1.1 算法
给定两个正整数
对
判定素数算法为1.4.1 基于开根号奇数整除判定算法优化-算法。
3.1.2 代码
package com.lunyu.algorithm.math.numberTheory;
import java.util.ArrayList;
import java.util.List;
/**
* 求素数算法
* @author lunyu
* @since 2022/7/14
*/
public class PrimeNumMain {
public static void main(String[] args) {
int n1 = 100, n2 = 200;
List<Integer> primeNums = new ArrayList<>();
for (int i = n1; i <= n2; i++) {
boolean isPrime = isPrimeOptimized3(i);
if (isPrime){
primeNums.add(i);
}
}
// TODO: 结果输出
System.out.println("整数" + n1 + ", " + n2 + "之间的素数为:");
for (Integer primeNum : primeNums) {
System.out.print(primeNum + " ");
}
}
/**
* 给定一个正整数n, 判定该数是否为素数
*/
private static boolean isPrimeOptimized3(int num){
if (1 >= num){
return false;
}
if (2 == num){
return true;
}
if (0 == num % 2){
return false;
}
// 整数num开方向下取整
double sqrtFloorNum = Math.floor(Math.sqrt(num));
for (int i = 3; i <= sqrtFloorNum;){
if (0 == num % i){
return false;
}
i += 2;
}
return true;
}
}
3.1.3 算法复杂度
易知外层循环时间复杂度为
因为有素数列的采集动作,因此这里空间复杂度是
时间复杂度 | 空间复杂度 |
---|---|
注: 上述算法还能再进一步优化,在外层循环中,我们处理好
, 可能存在的 这个特殊情况后,其中的循环变量,只取介于 到 的奇数进行判定,这样时间复杂度可减半,变为 。
3.2 外层全量奇数循环和内层开根号素数判定的算法
同样为了减少篇幅,我们直接使用2.4 基于外层全量奇数和内层开根号全量奇素数整除判定的算法优化中的算法,而不从头开始逐步优化。
3.2.1 算法
给定两个正整数
先求出小于等于
求出小于等于
3.2.2 代码
package com.lunyu.algorithm.math.numberTheory;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
/**
* 求素数算法
* @author lunyu
* @since 2022/7/14
*/
public class PrimeNumMain {
public static void main(String[] args) {
int n1 = 100, n2 = 200;
List<Integer> primeNums = new ArrayList<>();
getPrimeNumsOptimized2(n2, primeNums);
primeNums = primeNums.stream().filter(e -> e.intValue() >= n1)
.collect(Collectors.toList());
// TODO: 结果输出
System.out.println("整数" + n1 + ", " + n2 + "之间的素数为:");
for (Integer primeNum : primeNums) {
System.out.print(primeNum + " ");
}
}
/**
* 获得n以内(含n)的素数列
* @param n
* @param primeNums
*/
private static void getPrimeNumsOptimized2(int n, List<Integer> primeNums) {
if (1 >= n){
return;
}
// 如果n >= 2, 则n以内的素数默认含有2
primeNums.add(2);
// 对大于等3的奇数判定
for (int i = 3; i <= n;){
if (1 >= n){
return;
}
boolean isPrime = isPrimeOptimized4(i, primeNums);
if (isPrime){
primeNums.add(i);
}
i += 2;
}
}
/**
* 判定是否为素数
*/
private static boolean isPrimeOptimized4(int num, List<Integer> primeNums) {
// 整数num开方向下取整
double sqrtFloorNum = Math.floor(Math.sqrt(num));
for (Integer primeNum : primeNums) {
if (primeNum > sqrtFloorNum){
break;
}
if (0 == num % primeNum){
return false;
}
}
return true;
}
}
3.2.3 算法复杂度
易知,外层的for
循环其时间复杂度为
获得素数列,其空间复杂度为
时间复杂度 | 空间复杂度 |
---|---|
4. 从 开始计算大素数
从计算机诞生以来,计算超大素数就成为了可能。目前最大的已知素数为
本文即从算法可行的角度,从
4.1 迭代初始数列取开方追加增量素数列算法
我们怎么计算大素数呢?这里我要反其道而行之。先算一部分,然后再算一部分,最后算到我们想要的数为止。说的太含混了,下面以例子进行说明。
首先,我们先获取到素数
进行第二次循环。我们已知初始素数列
进行第三次循环。我们已知初始素数列
以此类推。
我们可以用这种方式,一直计算下去,得到任意的大的素数(如果算力允许的话)。
4.1.1 算法
从
设全量的初始素数列
4.1.2 代码
package com.lunyu.algorithm.math.numberTheory;
import com.google.common.collect.Lists;
import java.util.List;
/**
* 求素数算法
* @author lunyu
* @since 2022/7/14
*/
public class PrimeNumMain {
/**
* 素数上限
* 我们还是要设置一个上限,以便退出程序
*/
private static final int PRIME_NUM_LIMIT = 300000;
public static void main(String[] args) {
List<Integer> primeNums = Lists.newArrayList(2, 3);
int round = 1;
getPrimeNumsByRound(primeNums, round);
// TODO: 结果输出
for (Integer primeNum : primeNums) {
System.out.print(primeNum + " ");
}
}
/**
* 按轮次求大素数
*/
private static void getPrimeNumsByRound(List<Integer> primeNums, int round) {
// 获得已知素数列的最后一个素数
Integer lastPrimeNum = primeNums.get(primeNums.size() - 1);
// 迭代截止
if (lastPrimeNum >= PRIME_NUM_LIMIT){
return;
}
System.out.println("执行轮次 round:" + round);
// 执行算法
// 需新增的素数列
List<Integer> appendPrimeNums = new ArrayList<>();
for (int i = lastPrimeNum + 2; i <= (lastPrimeNum * lastPrimeNum - 2);){
if (i >= PRIME_NUM_LIMIT){
primeNums.addAll(appendPrimeNums);
return;
}
boolean isPrime = isPrime(i, primeNums);
if (isPrime){
appendPrimeNums.add(i);
}
i += 2;
}
primeNums.addAll(appendPrimeNums);
round ++;
getPrimeNumsByRound(primeNums, round);
}
/**
* 判定是否为素数
*/
private static boolean isPrime(int num, List<Integer> primeNums) {
for (Integer primeNum : primeNums) {
if (0 == num % primeNum){
return false;
}
}
return true;
}
}
4.1.3 算法复杂度
时间复杂度 | 空间复杂度 |
---|---|
4.2 循环初始数列取开方追加增量素数列算法
我们尝试把上面的算法用循环的方式实现。
4.2.1 算法
首先,我们求得对应的轮次和每个轮次下数据界限。求取的方式即执行while
循环,每次都取数值开方后向上取整的值,直到这些值小于等于
之后,循环这些轮次,根据开方的原则进行计算,求取大于等于数值界限的素数列。
如果素数列满足素数上限,则退出程序。
这里以例子简单说明一下。
我们求
易知,
于是,我们得到了4
个轮次,每个轮次的数值界限依次为
5, 24, 548, 300000
有了轮次和数值界限,我们就可以进行后面的循环和循环界定了。
第一个轮次,初始素数列
第二个轮次,素数列
因为第一步
我们把得到的要追加的素数列第一个素数
第三轮次,素数列
最后一轮,素数列
4.2.2 代码
package com.lunyu.algorithm.math.numberTheory;
import com.google.common.collect.Lists;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* 求素数算法
* @author lunyu
* @since 2022/7/14
*/
public class PrimeNumMain {
/**
* 素数上限
* 我们还是要设置一个上限,以便退出程序
*/
private static final int PRIME_NUM_LIMIT = 300000;
public static void main(String[] args) {
List<Integer> primeNums = Lists.newArrayList(2, 3);
getPrimeNums(primeNums);
// TODO: 结果输出
for (Integer primeNum : primeNums) {
System.out.print(primeNum + " ");
}
}
/**
* 获得素数列
* @param primeNums
*/
private static void getPrimeNums(List<Integer> primeNums) {
double primeNumLimit = PRIME_NUM_LIMIT;
// 先获得执行轮次
int round = 0;
// 每个轮次的界限值
List<Double> roundNumLimits = new ArrayList<>();
roundNumLimits.add(primeNumLimit);
while (primeNumLimit > 3 * 3){
primeNumLimit = Math.ceil(Math.sqrt(primeNumLimit));
roundNumLimits.add(primeNumLimit);
round ++;
}
Collections.reverse(roundNumLimits);
// 循环这些轮次
for (int i = 0; i <= round; i++){
// 获得已知素数列最后一个素数
Integer lastPrimeNum = primeNums.get(primeNums.size() - 1);
int roundNumLimit = roundNumLimits.get(i).intValue();
// 需追加的素数列
List<Integer> appendPrimeNums = new ArrayList<>();
for (int j = lastPrimeNum + 2; j <= lastPrimeNum * lastPrimeNum + 2;){
// 最后一个轮次判定的已越界,则跳出循环直接返回
if (i == round){
if (j > PRIME_NUM_LIMIT){
primeNums.addAll(appendPrimeNums);
return;
}
}
if (isPrime(j, primeNums)){
appendPrimeNums.add(j);
if (j >= roundNumLimit){
break;
}
}
j += 2;
}
// 在每个轮次内,我们保证追加的素数列最后一个元素大于等于对应的界限值
if (appendPrimeNums.isEmpty()){
continue;
}
int appendLastPrimeNum = appendPrimeNums.get(appendPrimeNums.size() - 1).intValue();
// 如果不满足,则继续计算素数,直到这个素数大于给定的临界值为止
while (appendLastPrimeNum < roundNumLimit){
int appendHeadPrimeNum = appendPrimeNums.get(0).intValue();
primeNums.add(appendHeadPrimeNum);
appendPrimeNums.remove(0);
// 我们约定这个地方一定能找到一个比界限值大的素数
for (int j = lastPrimeNum * lastPrimeNum + 4; j < appendHeadPrimeNum * appendHeadPrimeNum + 2;){
// 最后一个轮次判定的已越界,则跳出循环直接返回
if (i == round){
if (j > PRIME_NUM_LIMIT){
primeNums.addAll(appendPrimeNums);
return;
}
}
if (isPrime(j, primeNums)){
appendPrimeNums.add(j);
if (j >= roundNumLimit){
break;
}
}
j += 2;
}
lastPrimeNum = primeNums.get(primeNums.size() - 1);
appendLastPrimeNum = appendPrimeNums.get(appendPrimeNums.size() - 1).intValue();
}
primeNums.addAll(appendPrimeNums);
}
}
/**
* 判定是否为素数
*/
private static boolean isPrime(int num, List<Integer> primeNums) {
for (Integer primeNum : primeNums) {
if (0 == num % primeNum){
return false;
}
}
return true;
}
}
4.2.3 算法复杂度
时间复杂度 | 空间复杂度 |
---|---|
出处:https://www.cnblogs.com/lunyu/p/16495874.html
版权:本文版权归作者和博客园共有
转载:欢迎转载,但未经作者同意,必须保留此段声明;必须在文章中给出原文连接;否则必究法律责任
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· 没有源码,如何修改代码逻辑?
· PowerShell开发游戏 · 打蜜蜂
· 在鹅厂做java开发是什么体验
· WPF到Web的无缝过渡:英雄联盟客户端的OpenSilver迁移实战