java次方_JAVA计算指定上限的最大素数

今天来研究下通过JAVA进行指定上限的最大素数的计算。比如指定上限为1亿,通过程序算出结果为99999989,即不超过1亿的最大素数为99999989。

网上搜索到了这个问题的一种解法如下,我们命名为算法1:

/*

* 使用对撞指针,步长为1

*/

public static int maxPrime1(int num) {

int i = num;

while (i > 1) {

int m = 2, n = i - 1;

while (m <= n) {

if (m * n == i) {

break;

} else if (m * n > i) {

n--;

} else {

m++;

}

}

if (m > n) {

return i;

}

i--;

}

return 1;

}

为了调用上面的代码,主函数如下:

public static void main(String[] args) {

long beginTime = System.currentTimeMillis();

BigInteger num=new BigInteger(getNum(8));

System.out.println("最大素数: " + maxPrime1(num.intValue()));

// System.out.println("最大素数: " + maxPrime2(num.intValue()));

// System.out.println("最大素数: " + maxPrime3(num.longValue()));

// System.out.println("最大素数: " + maxPrime4(num));

// System.out.println("最大素数: " + maxPrimeSet(num.longValue()));

long endTime=System.currentTimeMillis();

System.out.println("用时:"+(endTime- beginTime)+"毫秒");

}

其中getNum是为了返回10的n次方的数,定义如下:

public static String getNum(int n){

String num="1";

for(int i=0;i

num=num+"0";

}

return num;

}

算法1在输入为10的8次方(即1亿)时,用时1102毫秒。输入为10的9次方时,算法1就力不从心了,算了超过10秒还没有出来结果。

从算法上来看,主要的问题在于n往下减的速度太慢,每次都减1,其实n可以一步到位算出,优化后得到算法2:

/*

* 使用对撞指针,下限步长为1,上限一步到位

*/

public static int maxPrime2(int num) {

int i = num;

while (i > 1) {

int m = 2, n = i/m;

while (m <= n) {

if (m * n == i) {

break;

} else if (m * n > i) {

n=i/m;

} else {

m++;

}

}

if (m > n) {

return i;

}

i--;

}

return 1;

}

算法2在输入为10的8次方时,用时1毫秒。输入为10的9次方时,用时也是1毫秒。输入为10的10次方时,超过了JAVA中int类型的上限,不能计算了。

于是修改算法2的输入类型,由int换成long,修改后得到算法3:

/*

* 使用对撞指针,下限步长为1,上限一步到位

*/

public static long maxPrime3(long num) {

long i = num;

while (i > 1) {

long m = 2, n = i/m;

while (m <= n) {

if (m * n == i) {

break;

} else if (m * n > i) {

n=i/m;

} else {

m++;

}

}

if (m > n) {

return i;

}

i--;

}

return 1;

}

算法3在输入为10的10次方时,用时7毫秒。输入为10的15次方时,用时也是893毫秒。输入为10的16次方时,用时是5299毫秒,得到最大素数为9999999999999937。输入为10的17次方时,算了超过10秒还没有出来结果。

因为long还是有数值的限制,于是考虑换成没有限制的BigInteger,得到算法4:

/*

* 使用对撞指针,下限步长为1,上限一步到位

*/

public static BigInteger maxPrime4(BigInteger num) {

BigInteger i = num;

BigInteger num1 = new BigInteger("1");

while (i.compareTo( num1) > 0) {

BigInteger m = new BigInteger("2"), n = i.divide(m);

while (m.compareTo(n) <= 0) {

BigInteger i2=m.multiply( n);

if (i2.compareTo(i) == 0) {

break;

} else if (i2.compareTo(i)> 0) {

n=i.divide(m);

} else {

m=m.add(num1);

}

}

if (m.compareTo(n) > 0) {

return i;

}

i=i.subtract(num1);

}

return num1;

}算法4在输入为10的15次方时,用时8974毫秒。输入为10的16次方时,算了超过10秒还没有出来结果。由此可见BigInteger的计算消耗比long要大,优点是没有数据的上限的限制。

以上4种算法的效率对比如下:

cfc548faa0fab84dda3c61f2f29473ac.png

另外也测了下指定上限算出全部素数的算法,代码如下:

/*

* 使用对撞指针,下限步长为1,上限一步到位

*/

public static long maxPrimeSet(long num) {

Set primes=new HashSet();

Long maxPrime=2L;

primes.add(maxPrime);

for(long i=3;i<=num;i++){

boolean isPrime=true;

for (long prime : primes) {

if(i/prime*prime==i) {

isPrime=false;

break;

}

}

if(isPrime) {

maxPrime=i;

primes.add(maxPrime);

}

}

System.out.println("素数个数:"+primes.size());

return maxPrime;

}

结果最大输入为10的5次方(再增加超过10秒还没有结果),输出如下:

素数个数:9592

最大素数: 99991

用时:2747毫秒

以上是关于最大索数计算的小探索,希望有兴趣的朋友可以帮看下上面的算法能否进一步优化,算出更大的结果。

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值