Question

我正在努力获得一个数字的所有主要因素。 for循环应该一直有效，直到找到匹配并且它应该中断并跳转到下一个if语句，该语句检查数字是否不等于零。

public class Factor {

    public static ArrayList <Integer> HoldNum = new ArrayList(); 

    public static void main(String[]args){
        Factor object = new Factor();
        object.Factor(104);
        System.out.println(HoldNum.get(0));
    }

    public static int Factor(int number){
        int new_numb = 0;
        int n=0;
        for( n = 1; n < 9; n++) {                 
            if (number % n == 0) {
                HoldNum.add(n);
                new_numb = number/n;
                break;           
            }
        }

        System.out.println(new_numb);
        if(new_numb < 0) {
            HoldNum.add(new_numb);
            return 1;
        } else {
            return Factor(new_numb);
        }                   

    }
}

Answer 1

至少有三个错误：

正如okiharaherbst所写，你的计数器不会增加。
你开始循环为1，所以你的％％1总是等于0而new_numb总是等于你的输入值，所以你将在104上无休止地循环。
new_numb永远不会小于0。

Answer 2

您要求提供递归解决方案。你走了：

public class Example {

    public static void main(String[] args) {
        System.out.println(factors(104));
    }

    public static List<Integer> factors(int number) {
        return factors(number, new ArrayList<Integer>());
    }

    private static List<Integer> factors(int number, List<Integer> primes) {
        for (int prim = 2; prim <= number; prim++) {
            if (number % prim == 0) {
                primes.add(prim);
                return factors(number / prim, primes);
            }
        }
        return primes;
    }
}

代码不是防弹的，它只是一个快速而肮脏的例子。

Answer 3

Java实现......

public class PrimeFactor {

public int divisor=2;
void printPrimeFactors(int num)
{

    if(num == 1)
        return;

    if(num%divisor!=0)
        {
        while(num%divisor!=0)
            ++divisor;          
        }
    if(num%divisor==0){

    System.out.println(divisor);
        printPrimeFactors(num/divisor);
    }

}
public static void main(String[] args)
{
    PrimeFactor obj = new PrimeFactor();
    obj.printPrimeFactors(90);
}

}

用于查找素因子的Java递归并不起作用

3 个答案: