Java 程序运行要花很长时间 公共类问题\u 3{ 公共静态void main（字符串…参数）{ 长限=600851475143L； 长最大初始因子=0； 用于（长数=2；数

我确信，上面的程序不是无限循环的。I使用

极限=13195进行测试并获得了所需的结果
29

我不明白为什么我的CPU要花很长时间运行它

编辑：
这是ProjectEuler.net问题3的代码
 您的算法的时间复杂度为O（n^2），这使得它对于较大的极限值不是非常有效

所以它很慢，因为您使用的算法很差。
这就是原因

public class Problem_3 {
    public static void main(String... args) {
        long limit = 600851475143L;
        long largestPrimeFactor = 0;

        for (long number = 2; number < limit; number++) {
            if (isPrime(number)) {
                if ((limit % number == 0)){
                    largestPrimeFactor = number; 
                }
            }
        }       
        System.out.println(largestPrimeFactor);
    }

    public static boolean isPrime(long number) {
        for (int i = 2; i < number; i++) {
            if (number % i == 0) {
                return false; 
            }
        }
        return true; 
    }
}

一个O（n^2）算法，n是这个长数字
600851475143L
代码的时间复杂度是O（n^2）。所以这不是一个适用于大数的好算法。可能的建议如下：

你对最大素数感兴趣，那么为什么不从最大值开始呢

long limit = 600851475143L;

虽然时间复杂度保持不变，但这肯定会比当前算法减少时间

但是，时间复杂度到底是什么。。？？你怎么计算呢。。？？O（N^2）是什么？？请解释

    for (long number = limit-1; number > 1; number--) {
        if (isPrime(number)) {
            if ((limit % number == 0)){
                largestPrimeFactor = number;
                 break; 
            }
        }
    }  

for（长数字=2；数字

上面是您的第一个for循环，您将在其中进行
n次迭代
。在这个函数中，您调用
isPrime（）
函数，该函数中再次有一个for循环
for（int i=2；i
再次有
n次迭代
。因此，基本上你有两个for循环，一个在另一个内部，这使得你的时间复杂度n*n=n^2
你将每个no传递给isPrime（long number）方法&同样，你已经使用for循环“for（int i=2；i
你可以知道这要花多少时间……也许你需要一个超级补偿

快乐编码
正如大家所说，你的代码不太省时，但看看代码，我可以猜测你正在努力寻找最大的素数因子，你可以尝试生成所有素数，然后从后面找到因子

 for (long number = 2; number < limit; number++)

import java.util.LinkedList；
分级筛{
公共静态链接列表筛选（长n）{
如果（n<2）返回新的LinkedList（）；
LinkedList primes=新LinkedList（）；
LinkedList nums=新建LinkedList（）；
对于（长i=2；长i=0）{
long nexttime=nums.remove（）；
对于（long i=nextPrime*nextPrime；i由于循环嵌套（一个循环在main中达到极限，另一个循环在isPrime中从该循环中调用），算法的时间复杂度为O（n^2）

这是一种标准方法，用于表示算法为不同大小的输入解决不同问题所需的时间

在您的情况下，大小是限制（600851475143L），因此解决此问题需要“600851475143^2的订单”，而如果限制为10（例如），则需要“10^2（即100）”

因此，如果限制为10的版本需要100毫秒（10平方），那么您的600851475143版本将需要36102249518151900000000毫秒（即600851475143L平方，如果我有一些零错误，请道歉）

时间复杂度的其他例子是O（1）或常数时间，其中算法所用时间与大小无关，或O（n）或线性时间，其中所用时间与编译的大小成正比？你的意思是“运行”？嗯…因为它是长时间运行的代码？@Julien“时间复杂度至少为O”是什么意思（限额2）@Java初学者算法的时间复杂度将算法运行所需的时间量化为输入长度的函数。它通常用于描述算法的性能。大O符号表示输入的大小达到无穷大时。这是一种渐近描述。@SnackySrikanth-参见。。…ProjectEuler的一个要点是，问题很容易通过蛮力以一种朴素的方式编码，但蛮力解决方案很少实用，因为它需要太长的时间才能得到答案。其想法是想出一个比蛮力尝试快得多的解决方案，例如通过找到一个合适的算法（n^2）？？？你能解释一下吗？这里没有。你能推荐一个好的算法吗？现在，它的时间复杂度是一样的，你会以值2作为最大的PrimeFactor结束…当你找到一个时，你应该停止删除…@Julien是的，时间复杂度是一样的，但执行时间肯定会比现在的算法少汉克斯指出了中断循环：）@AniketThakur非常感谢你的详细回答。但是，时间复杂性到底是什么？你如何计算它？O（N^2）是什么？请解释..你应该明确你说的是时间复杂度，而不是空间复杂度。@SnackySrikanth你可能想检查这个线程谢谢@Julien你能建议一个更好的方法来解决这个问题吗。。？？
import java.util.LinkedList;

 class Sieve{



       public static LinkedList<Long> sieve(long n){
               if(n < 2) return new LinkedList<Long>();
               LinkedList<Long> primes = new LinkedList<Long>();
               LinkedList<Long> nums = new LinkedList<Long>();

               for(long i = 2;i <= n;i++){ //unoptimized
                       nums.add(i);
               }

               while(nums.size() > 0){
                       long nextPrime = nums.remove();
                       for(long i = nextPrime * nextPrime;i <= n;i += nextPrime){
                               nums.removeFirstOccurrence(i);
                       }
                       primes.add(nextPrime);
               }
               return primes;
       }
}