使用递归在Java中打印素数

我用C编写了一个类似的函数，并且能够实现与java不同的所需结果。 下面是代码，它递归地检查一个数字是否为素数。 汇编说，我缺少一个返回语句。 如果素数是x，则要检查的数字。变量i是除数。（即）x/2，（x/2）-1，…0

---

如果我必须打印前1000个素数，那么这段代码的复杂性是多少。

乍一看，您的else语句中似乎缺少一个返回：

public int primes(int x, int i)
{
    if(i==1)
        return 1;
    if(x%i==0)
        return 0;
    else
        return primes(x, i-1);
}

编辑：另外，正如在Rgetman的回答中所说，如果（i==0），则第一个条件

中存在逻辑错误。如果（i==1）

，则应为

。使用上述编辑测试代码后，我的结果如下：

List of primes under 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

在这种情况下：

else
    primes(x, i-1);

你什么也不退。但是，编译器必须确保在所有情况下都返回某些内容。只要返回递归方法调用返回的内容：

else
    return primes(x, i-1);

另外，将第一个case的条件修改为
i==1
，这样它就可以在素数上正确地返回
1
。
您只需要在
else
中添加一个
return

else
    return primes(x, i-1);

那里的
return
将返回递归调用的结果，它们将沿着堆栈向上运行。但是，这可能会导致StackOverflowException

s.

您可以应用以下逻辑：

for (i = 1; i <= 100; i++) {              
    int counter=0;    
    for (num = i; num>=1; num--) {
        if (i%num==0) {
            counter = counter + 1;
        }
    }
    if (counter == 2) {
        //Appended the Prime number to the String
        primeNumbers = primeNumbers + i + " ";
    }   
}

（i=1；i=1；num--）的

{
如果（i%num==0）{
计数器=计数器+1；
}
}
如果（计数器==2）{
//将素数追加到字符串
素数=素数+i+“”；
}   
}

然后显示

素数

公共类PrintPrime{
public class PrintPrime {

    public static void main(String args[]) {
        for (int i = 2; i < 1000; i++) {
            primes(i, Math.ceil(Math.sqrt(i)));

        }
    }

    public static int primes(int x, double i) {
        if (i == 1)
            System.out.println(x);
        if (x % i == 0)
            return 0;
        else
            return primes(x, i - 1);
    }

}

公共静态void main（字符串参数[]）{
对于（int i=2；i<1000；i++）{
素数（i，Math.ceil（Math.sqrt（i））；
}
}
公共静态整数素数（整数x，双i）{
如果（i==1）
系统输出println（x）；
如果（x%i==0）
返回0；
其他的
返回素数（x，i-1）；
}
}

对于复杂性，在最坏的情况下，

i

会一直下降到0，因此如果

i

从

x/2开始，它大约是O（x）。但这将摊销到更小的值，因为显然不是每个数字都是素数（）。对于仅仅1000个素数，我怀疑它无论如何都会花费很长时间。@Ben不，它不会摊销到更小的素数，因为测试是按错误的顺序进行的。n=1000个素数意味着~n=8000个要测试的数字，通过O（n^2）算法；不要因为n=1000看起来很小（你确实说过“无论如何”…）就确信它会运行得很快——它的复杂度太高了（例如，这个算法显示了~n^2.2，~n^2.5的运行时行为。我的意思是OP的
primes
是O（x）（或O（n）或其他任何东西）。所以，如果他循环它是O（n^2），但这不会是绝对最坏的情况，因为OP已经声明他从
x/2
开始
i
，所以evens立即失败。然后要找到1000个素数
x
只需要7919个，所以对于大多数数字，素数不会递归太远。@Ben他们确实谈到了找到前1000个素数。我给了你证据，证明了这一点它比N^2更糟糕。你的算法的错误，在N个素数中产生。工作起来很有魅力。从C到Java的转换是罪魁祸首！
public class PrintPrime {

    public static void main(String args[]) {
        for (int i = 2; i < 1000; i++) {
            primes(i, Math.ceil(Math.sqrt(i)));

        }
    }

    public static int primes(int x, double i) {
        if (i == 1)
            System.out.println(x);
        if (x % i == 0)
            return 0;
        else
            return primes(x, i - 1);
    }

}

import java.util.Scanner;
public class Primenumm {

static int limit,flag;

public static void main(String[] args) {
    // TODO Auto-generated method stub

    System.out.println("Enter the Number :-");
    Scanner s=new Scanner(System.in);
    limit=s.nextInt();
    int i=0,j=limit;
    printNum(i,j);
}

private static int  printNum(int i, int j) {
    // TODO Auto-generated method stub

    if(j==0){
        return 1;
    }
    if(i%j==0){
        return  0;
    }
    else{

        return  printNum(i,j-1);
    }
}

import java.util.Scanner;

public class Primenumm {
     public static void main(String[] args) {
          System.out.println("Enter the Number :-");
          Scanner s = new Scanner(System.in);
          int limit = s.nextInt();
          for (int i = limit; i >= 1; i--) {
               if (primes(i, i - 1) == 1) {
                    System.out.println(i + " is a prime no");
               } else {
                    System.out.println(i + " is not a prime no");
               }
          }
     }

     private static int primes(int x, int i) {
          if (i == 1) {
               return 1;
          }
          try {
               if (x % i == 0) {
                    return 0;
               } else {
                    return primes(x, i - 1);
               }
          } catch (Exception e) {
               return 1;
          }
     }
}