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
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
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)
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种算法的效率对比如下:
另外也测了下指定上限算出全部素数的算法,代码如下:
/*
* 使用对撞指针,下限步长为1,上限一步到位
*/
public static long maxPrimeSet(long num) {
Setprimes=new HashSet();
Long maxPrime=2L;
primes.add(maxPrime);
for(long i=3;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毫秒
以上是关于最大索数计算的小探索,希望有兴趣的朋友可以帮看下上面的算法能否进一步优化,算出更大的结果。