Question

任何人都可以向我解释输出是如何产生的吗？

    // XXX Override some locations for Android Studio projects                                                                               
if (AndroidStudio.isAndroidStudioProject(self.root) === true) {
    selfEvents.emit('log', 'Android Studio project detected');
    this.builder = 'studio';
    this.android_studio = true;
    this.locations.configXml = path.join(self.root, 
    'app/src/main/res/xml/config.xml');
    this.locations.strings = path.join(self.root, 
    'app/src/main/res/values/strings.xml');
    this.locations.manifest = path.join(self.root, 
    'app/src/main/AndroidManifest.xml');
    // We could have Java Source, we could have other languages                                                                          
    this.locations.javaSrc = path.join(self.root, 'app/src/main/java/');
    this.locations.www = path.join(self.root, 'app/src/main/assets/www');
    this.locations.res = path.join(self.root, 'app/src/main/res');
}

输入5 产量在基本案例之外：0

在基本案例中：1

在基本案例之外：1

基础案例：2

在基本案例之外：2

基础案例：3

在基本案例之外：3

在基本案例中：4

在基本案例之外：4

在基本案例中：5

在基本案例之外：5

Answer 1

我会稍微改变你的代码：

public static void recursionTest(int num) {
    if (num > 0) {
        recursionTest(num - 1);
        System.out.println("Inside the inductive case: " + num);
        // make sure to return here so that the base case message
        // does not accidentally get printed
        return;
    }

    System.out.println("Inside the base case: " + num);
}

这输出以下内容：

Inside the base case: 0
Inside the inductive case: 1
Inside the inductive case: 2
Inside the inductive case: 3
Inside the inductive case: 4
Inside the inductive case: 5

递归的 base 情况是结束递归的情况。在您的情况下，基数情况发生在数字达到零时，我们不进行进一步的递归调用。否则，我们继续进行递归调用，将输入数字递减1。

输出看起来倒退的原因是我们实际命中的第一个print语句是基本情况。我们只在递归的路上打印归纳语句。

Demo

Answer 2

我们知道java递归使用stack来执行程序。无论何时处理递归，最好的方法是想象一个堆栈并将数据执行（方法调用）放入堆栈中并逐步进行...

如果您的输入是5 ...

，则在您的情况下

stack would be -> 5 -> recursive call { recursionTest(4); print(inside=5); print(outside=5;) }
stack would be -> 4 -> recursive call { recursionTest(3) print(inside=4); print(outside=4;) }
stack would be -> 3 -> recursive call { recursionTest(2) print(inside=3); print(outside=3;) }
stack would be -> 2 -> recursive call { recursionTest(1) print(inside=2); print(outside=2;) }
stack would be -> 1 -> recursive call { recursionTest(0) print(inside=1); print(outside=1;) }

finally recursion(0)...

当数字为0时，它将离开if并打印第一行

Outside the base case: 0

然后它以相反的顺序运行，因为方法调用已经堆叠（LIFO），从1到5是自下而上，因为1是堆栈中的最后一个输入，5是最后一个元素是堆栈...

希望有所帮助

Answer 3

您使用了一种不寻常的递归形式。最好坚持使用标准，一致的形式，以便在阅读代码时始终知道会发生什么。

递归函数的标准形式是：

function(context):
    if (context in simple form)
        return base case
    else
        simplify context
        call function(simplified context)
        return induction of results

规范示例：

int factorial(int n) {
    if (n <= 1)
        return 1;
    else
        return n * factorial(n - 1);
}

或者在你的情况下：

public static void recursionTest(int num) {
    if (num == 0) {
        System.out.println("base case: " + num);
    } else {
        System.out.println("inductive case: " + num);
        recursionTest(num - 1);
    }
}

如果你严格遵守这个表格，你会发现递归更容易构建和阅读。

Answer 4

使用递归调用时，它会在内存中创建一个堆栈。堆栈保存不完整的任务。这里当程序执行代码recursionTest(num - 1);时，它将前一个任务，即函数体的其余部分放在一个堆栈中。像这样的事情发生了：

现在，当创建完整堆栈时，从程序中删除递归调用，然后执行它。你会明白的。

初学者java递归测试

4 个答案:

Demo