Java 用递归理解primeFactorsR方法_Java_Recursion

Java 用递归理解primeFactorsR方法

java recursion

Java 用递归理解primeFactorsR方法,java,recursion,Java,Recursion,我有下面的方法，在本例中显示一个数字的所有素数倍数20。我了解该方法的大部分递归行为，但在打印数字5之后，我有点困惑，为什么n在上一次调用中为5时（即在执行第三个递归方法时）返回到10 我在控制台输出中添加了更多信息，以使递归调用链可见。 recursionLevel显示递归的深度。每个primeFactorsR-函数调用接收唯一的ID（请参见funcId-变量）。函数ID序列创建唯一的递归调用路径-recursionPath public class Tester { stati

我有下面的方法，在本例中显示一个数字的所有素数倍数20。我了解该方法的大部分递归行为，但在打印数字5之后，我有点困惑，为什么n在上一次调用中为5时（即在执行第三个递归方法时）返回到10

我在控制台输出中添加了更多信息，以使递归调用链可见。

recursionLevel

显示递归的深度。
每个

primeFactorsR

-函数调用接收唯一的ID（请参见

funcId

-变量）。
函数ID序列创建唯一的递归调用路径-

recursionPath

public class Tester {

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

    public static void primeFactors(int n, int recursionLevel) {
        primeFactorsR(n, n - 1, recursionLevel, null);
    }

    static int count1 = 1, count2 = 1, count3 = 1, count4 = 1;
    private static int recursionId = 1;

    public static void primeFactorsR(int n, int m, int recursionLevel, String recursionPath) {
        int funcId = recursionId++;

        if (recursionPath == null)
            recursionPath = String.format("%s", funcId);
        else
            recursionPath = String.format("%s-%s", recursionPath, funcId);

        if (isPrime(n)) {
            System.out.println(String.format("n %s recursionLevel %s recursionPath %s", n, recursionLevel, recursionPath));
            System.out.println("method1 " + count1++);
        } else if (n % m == 0) {
            System.out.println(String.format("n %s m %s recursionLevel %s recursionPath %s", n, m, recursionLevel, recursionPath));
            System.out.println("method2: " + count2++);
            primeFactorsR(m, m - 1, recursionLevel + 1, recursionPath);

            System.out.println(String.format("n %s m %s recursionLevel %s recursionPath %s", n, m, recursionLevel, recursionPath));
            System.out.println("method3: " + count3++);
            primeFactorsR(n / m, (n / m) - 1, recursionLevel + 1, recursionPath);
        } else {
            System.out.println(String.format("n %s m %s recursionLevel %s recursionPath %s", n, m, recursionLevel, recursionPath));
            //System.out.println("n " + n + " m - 1 " + ( m-1));
            System.out.println("method4: " + count4++);
            primeFactorsR(n, m - 1, recursionLevel + 1, recursionPath);
        }
    }

    public static void main(String[] args) {
        primeFactors(20, 1);
    }

}

公共类测试器{
静态布尔isPrime（int p）{
对于（int i=2；i


结果:
n 20 m 19 recursionLevel 1 recursionPath 1
method4: 1
n 20 m 18 recursionLevel 2 recursionPath 1-2
method4: 2
n 20 m 17 recursionLevel 3 recursionPath 1-2-3
method4: 3
n 20 m 16 recursionLevel 4 recursionPath 1-2-3-4
method4: 4
n 20 m 15 recursionLevel 5 recursionPath 1-2-3-4-5
method4: 5
n 20 m 14 recursionLevel 6 recursionPath 1-2-3-4-5-6
method4: 6
n 20 m 13 recursionLevel 7 recursionPath 1-2-3-4-5-6-7
method4: 7
n 20 m 12 recursionLevel 8 recursionPath 1-2-3-4-5-6-7-8
method4: 8
n 20 m 11 recursionLevel 9 recursionPath 1-2-3-4-5-6-7-8-9
method4: 9
n 20 m 10 recursionLevel 10 recursionPath 1-2-3-4-5-6-7-8-9-10
method2: 1
n 10 m 9 recursionLevel 11 recursionPath 1-2-3-4-5-6-7-8-9-10-11
method4: 10
n 10 m 8 recursionLevel 12 recursionPath 1-2-3-4-5-6-7-8-9-10-11-12
method4: 11
n 10 m 7 recursionLevel 13 recursionPath 1-2-3-4-5-6-7-8-9-10-11-12-13
method4: 12
n 10 m 6 recursionLevel 14 recursionPath 1-2-3-4-5-6-7-8-9-10-11-12-13-14
method4: 13
n 10 m 5 recursionLevel 15 recursionPath 1-2-3-4-5-6-7-8-9-10-11-12-13-14-15
method2: 2
n 5 recursionLevel 16 recursionPath 1-2-3-4-5-6-7-8-9-10-11-12-13-14-15-16
method1 1
n 10 m 5 recursionLevel 15 recursionPath 1-2-3-4-5-6-7-8-9-10-11-12-13-14-15
method3: 1
n 2 recursionLevel 16 recursionPath 1-2-3-4-5-6-7-8-9-10-11-12-13-14-15-17
method1 2
n 20 m 10 recursionLevel 10 recursionPath 1-2-3-4-5-6-7-8-9-10
method3: 2
n 2 recursionLevel 11 recursionPath 1-2-3-4-5-6-7-8-9-10-18
method1 3
n 20 m 19递归级别1递归路径1
方法4:1
n 20 m 18递归二级递归路径1-2
方法4:2
n 20 m 17递归3级递归路径1-2-3
方法4:3
n 20 m 16递归4级递归路径1-2-3-4
方法4:4
n 20 m 15递归5级递归路径1-2-3-4-5
方法4:5
n 20 m 14递归6级递归路径1-2-3-4-5-6
方法4:6
n 20 m 13递归7级递归路径1-2-3-4-5-6-7
方法4:7
n 20 m 12递归8级递归路径1-2-3-4-5-6-7-8
方法4:8
n 20 m 11递归第9级递归路径1-2-3-4-5-6-7-8-9
方法4:9
n 20 m 10递归10级递归路径1-2-3-4-5-6-7-8-9-10
方法2:1
n 10 m 9递归11级递归路径1-2-3-4-5-6-7-8-9-10-11
方法4:10
n 10 m 8递归级别12递归路径1-2-3-4-5-6-7-8-9-10-11-12
方法4:11
n 10 m 7递归级别13递归路径1-2-3-4-5-6-7-8-9-10-11-12-13
方法4:12
n 10 m 6递归级别14递归路径1-2-3-4-5-6-7-8-9-10-11-12-13-14
方法4:13
n 10 m 5递归级别15递归路径1-2-3-4-5-6-7-8-9-10-11-12-13-14-15
方法2:2
n 5递归级别16递归路径1-2-3-4-5-6-7-8-9-10-11-12-13-14-15-16
方法1
n 10 m 5递归级别15递归路径1-2-3-4-5-6-7-8-9-10-11-12-13-14-15
方法3:1
n 2递归级别16递归路径1-2-3-4-5-6-7-8-9-10-11-12-13-14-15-17
方法1 2
n 20 m 10递归10级递归路径1-2-3-4-5-6-7-8-9-10
方法3:2
n 2递归级别11递归路径1-2-3-4-5-6-7-8-9-10-18
方法13
从结果中检查以下行：
n 10 m 5 recursionLevel 15 recursionPath 1-2-3-4-5-6-7-8-9-10-11-12-13-14-15
method2: 2
n 5 recursionLevel 16 recursionPath 1-2-3-4-5-6-7-8-9-10-11-12-13-14-15-16
method1 1
n 10 m 5 recursionLevel 15 recursionPath 1-2-3-4-5-6-7-8-9-10-11-12-13-14-15
method3: 1
n 10 m 5递归级别15递归路径1-2-3-4-5-6-7-8-9-10-11-12-13-14-15
方法2:2
n 5递归级别16递归路径1-2-3-4-5-6-7-8-9-10-11-12-13-14-15-16
方法1
n 10 m 5递归级别15递归路径1-2-3-4-5-6-7-8-9-10-11-12-13-14-15
方法3:1
ID为15的函数，称为ID为16的函数，其打印行：
n 5 recursionLevel 16 recursionPath 1-2-3-4-5-6-7-8-9-10-11-12-13-14-15-16
n 5递归级别16递归路径1-2-3-4-5-6-7-8-9-10-11-12-13-14-15-16
在此之后，调用从16返回到15，函数15中的n
值仍然是10
，这是因为在第二个if语句n%m==0
中，它对primeFactorsR
进行了两次调用。第一个调用将引导您深入堆栈，在堆栈中5是素数。然后，它返回堆栈，直到到达停止的位置，并在第二个print语句上移动，给出第二个n10 m 5。这是您的输出，它在每一层都缩进，并在第一次进入primeFactorsR
和完成时打印出它在堆栈中的深度。它向右移动的地方会深入堆栈，上面的层会暂停。当层完成处理后，它将返回到上面的层，如果该层还有更多的工作要做，那么它将从停止的位置继续
We are the top layer
n 20 m 19
method4: 1
   We are 1 layers deep
   n 20 m 18
   method4: 2
      We are 2 layers deep
      n 20 m 17
      method4: 3
         We are 3 layers deep
         n 20 m 16
         method4: 4
            We are 4 layers deep
            n 20 m 15
            method4: 5
               We are 5 layers deep
               n 20 m 14
               method4: 6
                  We are 6 layers deep
                  n 20 m 13
                  method4: 7
                     We are 7 layers deep
                     n 20 m 12
                     method4: 8
                        We are 8 layers deep
                        n 20 m 11
                        method4: 9
                           We are 9 layers deep
                           n 20 m 10
                           method2: 1
                              We are 10 layers deep
                              n 10 m 9
                              method4: 10
                                 We are 11 layers deep
                                 n 10 m 8
                                 method4: 11
                                    We are 12 layers deep
                                    n 10 m 7
                                    method4: 12
                                       We are 13 layers deep
                                       n 10 m 6
                                       method4: 13
                                          We are 14 layers deep
                                          n 10 m 5
                                          method2: 2
                                             We are 15 layers deep
                                             Prime 5
                                             method1 1
                                             Finished with layer 15
                                          n 10 m 5
                                          method3: 1
                                             We are 15 layers deep
                                             Prime 2
                                             method1 2
                                             Finished with layer 15
                                          Finished with layer 14
                                       Finished with layer 13
                                    Finished with layer 12
                                 Finished with layer 11
                              Finished with layer 10
                           n 20 m 10
                           method3: 2
                              We are 10 layers deep
                              Prime 2
                              method1 3
                              Finished with layer 10
                           Finished with layer 9
                        Finished with layer 8
                     Finished with layer 7
                  Finished with layer 6
               Finished with layer 5
            Finished with layer 4
         Finished with layer 3
      Finished with layer 2
   Finished with layer 1
Finished

当我调试->使用netbeans进入时，它显示method3 n=20 m=10首先执行，然后method3 n=10 m=5执行，这是最后两个方法，而您的输出显示的是另一种方式，因此换句话说，method3在method2正确返回之前不会执行？。。。但是为什么method3执行前10和5，而在recursionPath=10（firstone）中首先传递了20和10。。。顺便说一句，谢谢你的解释。不要试图用你的“方法”来识别函数。使用

recursionPath识别相同的函数。

rec中的最后一个数字
n 5 recursionLevel 16 recursionPath 1-2-3-4-5-6-7-8-9-10-11-12-13-14-15-16
We are the top layer
n 20 m 19
method4: 1
   We are 1 layers deep
   n 20 m 18
   method4: 2
      We are 2 layers deep
      n 20 m 17
      method4: 3
         We are 3 layers deep
         n 20 m 16
         method4: 4
            We are 4 layers deep
            n 20 m 15
            method4: 5
               We are 5 layers deep
               n 20 m 14
               method4: 6
                  We are 6 layers deep
                  n 20 m 13
                  method4: 7
                     We are 7 layers deep
                     n 20 m 12
                     method4: 8
                        We are 8 layers deep
                        n 20 m 11
                        method4: 9
                           We are 9 layers deep
                           n 20 m 10
                           method2: 1
                              We are 10 layers deep
                              n 10 m 9
                              method4: 10
                                 We are 11 layers deep
                                 n 10 m 8
                                 method4: 11
                                    We are 12 layers deep
                                    n 10 m 7
                                    method4: 12
                                       We are 13 layers deep
                                       n 10 m 6
                                       method4: 13
                                          We are 14 layers deep
                                          n 10 m 5
                                          method2: 2
                                             We are 15 layers deep
                                             Prime 5
                                             method1 1
                                             Finished with layer 15
                                          n 10 m 5
                                          method3: 1
                                             We are 15 layers deep
                                             Prime 2
                                             method1 2
                                             Finished with layer 15
                                          Finished with layer 14
                                       Finished with layer 13
                                    Finished with layer 12
                                 Finished with layer 11
                              Finished with layer 10
                           n 20 m 10
                           method3: 2
                              We are 10 layers deep
                              Prime 2
                              method1 3
                              Finished with layer 10
                           Finished with layer 9
                        Finished with layer 8
                     Finished with layer 7
                  Finished with layer 6
               Finished with layer 5
            Finished with layer 4
         Finished with layer 3
      Finished with layer 2
   Finished with layer 1
Finished