Max 和 Min 的递归范围输出

Question

你好，我是 java 编码（初学者级别）的新手，我正在学习如何使用递归，但我正在做一些练习，我使用最小值和最大值来获得范围。

我希望输出是这样的，如果最小值为 2，最大值为 10，则输出 2 3 4 5 6 7 8 9 10。它也在最小值和最大值之间打印出来，但我不知道我实际上是如何获取输出的。

下面是代码：

//package methods;
public class MethodsRecursiveRange {

     public static void main(String[] args) {

          int count = 0;
          System.out.println( Range(count));                                                         

     }

     public static int Range (int count) {

          int min = 2;
          int max = 10;

          for ( int i = 0; i < max ; i++) {

               System.out.println(Range(count));
               Range(count);
          }
          return (0); 
     }
}

递归函数出现 stack overflow 错误。

Answer 1

尝试像下面这样的东西，你可以在电流 >= 最大值时停止。请找到代码的内联注释。

public class MethodsRecursiveRange {

    public static void main(String[] args) {
        Range(2,10); // Start
    }

    public static int Range (int curr, int max) {
        System.out.println(curr);   // Print the current value
        if(max<=curr) {             // Check if the Current value is greater or equal to Maximum limit
            return 0;               // Stop the recursion with 0 as return value
        } 
        return Range(++curr,max);   // Continue recursion with keeping max same, increment current value and invoke Range 

    }
}

Answer 2

您使用 for 循环破坏了递归的目的。

关于递归function/method最重要的三件事：

终止条件。
递归调用 method/function 的值。
其中（before/after 递归调用）处理参数。

按如下操作：

public class Main {
    public static void main(String[] args) {
        range(2, 10);
    }

    public static void range(int min, int max) {
        if (max <= min - 1) {// The terminating condition
            return;
        }
        range(min, max - 1);// The recursive call
        System.out.print(max + " ");// Processing the parameter(s)
    }
}

输出：

2 3 4 5 6 7 8 9 10

附带说明一下，您应该始终遵循 Java naming conventions 例如方法的名称应该是 range 而不是 Range.

Answer 3

由于您想递归地从最小值打印到最大值，因此对于递归函数，重要的是要有一个基本条件，从该条件开始您的代码将停止递归调用并开始弹出堆栈。因此，在下面的代码中，您使用 min 和 max 调用递归函数 Range，此处 Range 函数每次都会被调用，直到满足基本条件并打印出每次调用计数为 +1 并继续压入堆栈。一旦满足基本条件，它就会开始弹出，代码将成功结束。

public static void main(String[] args) {
    // Range(min, max)
    Range(2, 10);
}

public static void Range(int count, int max) {
    System.out.println(count);

    // Base condition
    if(count >= max) return;

    // Recursive call
    Range(count + 1, max);
}

Answer 4

在递归方法中你需要做的第一件事是有一个终止条件。如果条件为真，则该方法终止。如果条件为假，该方法会调用自身但会更改其参数。在下面的代码中，它实际上是相反的。如果条件为真，方法调用自身，如果条件为假，方法终止。

public class Tester {
    private static void printNum(int num, int limit) {
        if (num <= limit) {
            System.out.printf("%d ", num);
            printNum(num + 1, limit);
        }
        else {
            System.out.println();
        }
    }

    public static void main(String[] args) {
        printNum(2, 10);
    }

最初，该方法是从方法 main() 中调用的，具有起始编号和结束编号。在初始调用中，num = 2 和 limit = 10。这意味着条件为真，因此数字 2 后面会打印一个 space。然后调用相同的方法，但第一个参数等于 3，第二个参数相同，即 10.

所以在第二次调用中，num = 3 和 limit = 10。该方法然后在其后打印 3 和一个 space，然后使用参数 4 和10.

最终方法 printNum() 被调用 num = 11 和 limit = 10 这意味着条件 [ if (num <= limit) ] 为假所以该方法不会调用自身并打印换行符。一旦方法不调用自身，递归停止。

如果递归方法没有终止条件，它将继续调用自身。每次调用都需要内存来存储本地方法变量和其他东西。所以每次递归调用都意味着你的程序需要更多的内存。 Java 限制了您可以进行的递归调用次数。一旦你超过了这个限制，Java 抛出一个 WhosebugError 并强行终止你的程序。

Answer 5

我知道的最简单的方法就是这样做。

if min <= max 打印最小值和更新最小值的调用范围
其他return.

range(2,10);

public static void range(int min, int max) {
    if (min <= max) {
       System.out.print(min + " ");
       range(min+1, max);
    }
}

它是这样工作的。

第一次从主程序调用。
输入的范围。
最小 = 2 和最大 = 10
最小值 <= 最大值吗？
是的，所以输出最小值 2
现在跟注范围为 3 和 10（前一分钟 +1）
输入范围
最小 = 3 和最大 = 10
最小 <= 最大吗？
是的，所以输出最小值 3
现在跟注范围为 4 和 10（前一分钟 + 1）
输入范围
最小 = 4 和最大 = 10
如果最小值 <= 最大值？
是的，所以输出最小值 4
现在跟注范围为 5 和 10（之前的最小值 + 1）
以这种方式继续，直到 min > max

最终 min > max 并且整个调用堆栈将展开并 return 到调用程序。

Max 和 Min 的递归范围输出

Recursive Range Output from Max and Min

java

range

max

min