为什么在递归调用之后执行此语句？
在递归调用之后执行该语句的原因是为了确保在递归过程中的每一层都能够完成相应的操作后再进行下一步。递归是一种函数调用自身的技术，当一个函数在执行过程中调用自身，会将执行流程推入函数调用栈中，形成一个函数调用的层级结构。
在递归调用的过程中，每一层函数都会有自己的局部变量、参数和执行流程。当递归调用达到终止条件时，最底层的函数开始逐层返回，并执行之后的语句。
执行递归调用之后的语句的目的有几个方面的考虑：
- 终止条件判断：在递归调用之后执行的语句通常用于判断是否达到递归的终止条件。如果达到了终止条件，则可以进行相应的操作或者返回结果；如果没有达到终止条件，则继续递归调用。
- 数据处理或操作：在递归调用之后执行的语句可以用于对递归过程中的数据进行处理或者执行特定的操作。例如，可以对递归过程中的每一层的数据进行累加、合并、计算等操作。
- 返回结果处理：在递归调用结束后，最底层的函数开始逐层返回，返回结果可以在执行递归调用之后的语句中进行处理，例如将结果进行累加、组合、转换等操作。
总结来说，在递归调用之后执行的语句主要用于终止条件的判断、数据的处理和返回结果的处理。通过合理安排递归调用之后的语句，可以确保递归函数能够正确地完成所需的操作，并最终得到期望的结果。
请注意，以上回答中没有提及云计算、IT互联网领域的名词、产品和产品介绍链接，因为要求不能提及云计算品牌商。如需了解更多相关内容，建议参考相关的学习资料或者云计算领域的官方文档。
相关·内容
1回答
当我在打印之前调用函数时，为什么递归是向后的，而如果我在调用函数之后进行打印，为什么要向后递归？
由于某些原因，我不明白为什么递归方法在函数被调用之前向后打印，为什么在调用函数之前不向后打印。
有人能给我解释一下吗？
public void tricky1(int n) {
if (n >= 0) {
System.out.print(n);
tricky1(n - 2);
}
}
第二
public void tricky2(int n) {
if (n >= 0) {
tricky2(n - 2);
浏览 2提问于2022-05-01得票数 0
2回答
当满足条件时，我有一个简单的函数返回True或False。但返回语句并没有像我预期的那样起作用。有人能帮我指出我正在犯的错误吗？
graph = {
'f': ['g', 'i'],
'g': ['h'],
'h': [],
'i': ['g', 'k'],
'j': ['i'],
'k': []
}
def hasPath(graph,source,des):
arr = graph[sour
浏览 4提问于2022-12-02得票数 0
回答已采纳
2回答
这是递归二进制搜索的代码。
不使用使用cout << binarySearch
int binarySearch(int arr[], int l, int h, int key)
{
int mid = l + (h - l) / 2;
if (l <= h)
{
if (arr[mid] == key)
{
return mid;
}
else if (key < arr[mid])
{
binarySearch(a
浏览 8提问于2022-01-18得票数 0
首先，我的代码：
import java.util.Scanner;
public class recursionQuestion {
public static void methodB(boolean b) {
if(b == true) {
System.out.println("'b' is true!");
} else {
methodA();
}
}
public static void methodA() {
Scanner keyboard = new Scanner(
浏览 1提问于2014-12-15得票数 3
回答已采纳
3回答
void count(int n)
{
static int d=1;
printf("%d", n);
printf("%d", d);
d++;
if(n>1)
count(n-1);
printf("%d", d);
}
void main()
{
count(3);
}
我计算的输出是3 1 2 2 1 3 4
和输出由书3 1 2 2 1 3 4 4给出
我知道为什么我的答案不同。
在图书解决方案中，他们总是在"if“循环中执行printf语句。
浏览 0提问于2017-12-12得票数 1
我的代码中有一个递归函数，如下所示：
let rec func (a,b)
match (a,b) with
| condition 1 -> func a+1 b
| condition 2 -> print "%s" done
| _ then func a b+1 //<-- It enters here after going into the else ()!!
if a = b then func 0 0
else ()
问题是，当匹配部分结束时，它转到if语句，但不匹配它，
浏览 1提问于2014-03-18得票数 0
3回答
下面的代码是我的练习：
def rec_count(number):
print(number)
# Base case
if number == 0:
return 0
rec_count(number - 1) # A recursive call with a different argument
print(number)
rec_count(5)
它提供了这样的输出：
5
4
3
2
1
0
1
2
3
4
5
我不明白为什么在达到0之后，负数不再继续，而是从1到5。有人能解释一下吗？
提前感谢
浏览 5提问于2022-01-25得票数 -2
回答已采纳
1回答
我编写了以下代码
#include <stdio.h>
void recurse();
int main()
{
recurse();
return 0;
}
void recurse()
{
static int n=987654321;
if(n==0)
return ;
printf("%d",n%10);
n=n/100;
int a=n;
recurse();
if(a!=0)
printf("%d",a%10);
}
我不明白为什么产量会达到135799753
浏览 2提问于2017-04-22得票数 0
回答已采纳
计算复合利息的平凡程序，i= P(1+n)^y。
public class Interest {
public static void main(String[] args){
double sum = calculate(1000,10,3);
System.out.println(sum);
//sanity check, using non-recursive formula:
double amt = 1000*(Math.pow(1 + 0.1, 3));
System.out.println
浏览 4提问于2015-11-13得票数 2
回答已采纳
7回答
这是我的代码
using System;
public class Program
{
public static void Method(int flowerInVase)
{
if (flowerInVase > 0)
{
Method(flowerInVase - 1);
Console.WriteLine(flowerInVase);
}
}
public static void Main()
{
Method(3);
浏览 2提问于2013-01-31得票数 2
回答已采纳
int main ()
{
static int i = 5;
if (--i)
{
return main();
}
printf("%d", i);
return 0;
}
输出: 0
int main()
{
static int i = 5;
if (--i)
{
main();
}
printf("%d", i);
return 0;
}
输出:0 0 0
int main()
{
static int i =
浏览 1提问于2020-01-23得票数 0
回答已采纳
问题链接：https://leetcode.com/problems/binary-tree-pruning/ 基本上，给定二叉树的根，返回相同的树，其中不包含1的每个子树(给定树)都已被删除。 我的代码： /**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* T
浏览 26提问于2021-07-25得票数 1
回答已采纳
3回答
我在一个答案中看到了这个算法，现在我怀疑它是一个带有两个参数的递归函数，一个整数数组和一个整数。我们的目标是打印数组，但在相反的顺序下，我测试了它，它工作了！但我不知道为什么..。下面是函数
public static void reverse(int[] a, int position) {
// BASE
if (position == a.length) return;
// RECURSIVE
reverse(a, position + 1);
System.out.println
浏览 5提问于2013-04-16得票数 0
回答已采纳
1回答
我想知道如何可以在触发器“而不是DELETE”中执行DELETE查询而不调用同一个触发器？它是SQL特性吗？有人能解释一下为什么会这样吗？
浏览 2提问于2021-01-05得票数 1
回答已采纳
1回答
我的任务是创建一个递归函数，该函数接受一个数字数组，并将其转换为到目前为止所有数字的累积和的数组，因此：
1，2，3，4，5变成1，3，6，10，15
这就是我想出来的：
#include <stdio.h>
int cumul(int tab[], int length, int ind) {
if (ind > 0) {
tab[ind] += tab[ind-1];
}
if (ind < length) {
cumul(tab, length, ind+1);
}
return 0;
}
浏览 1提问于2015-03-04得票数 2
回答已采纳
2回答
我执行了这个程序，无法理解为什么输出是"0“四次。有人能帮我理解它的工作原理吗？我不明白为什么"printf“在条件失败时执行，为什么要执行四次。
int main()
{
static int i=5;
if(--i)
{
main();
printf("%d ",i);
}
}
浏览 1提问于2013-10-30得票数 2
回答已采纳
编写一个接受整数参数n并输出n个字符的方法writeChars，如下所示。输出的中间字符应该始终是星号("*")。如果你被要求写出一个偶数的字符，那么中间会有两个星号("**")。在星号之前，您应该写出小于字符("<")。在星号之后，您应该写出大于字符(">")。
我设法解决了这个问题，但不太明白一句话：
public void writeChars(int n) {
if ( n < 1 ) {
throw new IllegalArgumentException();
}
浏览 3提问于2017-11-13得票数 0
回答已采纳
1.情况
我正在用Python编写一个项目，并且我得到了很多以下类型的函数：
from PyQt5.QtCore import *
import functools
...
def myfunc(self, callback, callbackArg):
'''
This function hasn't finished its job when it hits the
return statement. Provide a callback function and a
callbac
浏览 1提问于2019-03-30得票数 1
回答已采纳
5回答
递归调用后的代码
、、
为什么在递归之后调用System.out.println(res)还在运行？我认为它永远不会到达System.out.println(res)；
public class recursion
{
public static void main(String[] args)
{
recursion p = new recursion();
p.perms(4, "");
}
public void perms(int remaining, String res)
{
if (remainin
浏览 1提问于2013-05-31得票数 3
回答已采纳
2回答
void myMethod( int counter) {
if(counter == 0)
return;
else {
System.out.println("hello" + counter);
myMethod(--counter);
System.out.println("" + counter);
//return;
}
}
当我将3传递给函数时，该函数的输出将为
hello3
hello2
hello1
0
1
2
我理解为什么output有he
浏览 24提问于2018-06-05得票数 -5
回答已采纳
function printNumbers(from, to) {
let current = from;
function go() {
alert(current);
if (current < to) {
setTimeOut(go, 1000); //recursion to function go()
}
current++; // because of recursion execution should not reach this point
}, 1000);
}
printNumbers(5, 10);
浏览 1提问于2020-05-06得票数 0
回答已采纳
1回答
我很难理解为什么这个函数不返回：
def rem(x, a):
"""
x: a non-negative integer argument
a: a positive integer argument
returns: integer, the remainder when x is divided by a.
"""
if x == a:
return 0
elif x < a:
return x
else:
rem(x-a
浏览 0提问于2019-02-21得票数 1
回答已采纳
我在试着理解递归是如何工作的。由于递归调用的位置，我有两个具有不同输出的代码。我知道它应该有不同的输出，但我不明白为什么输出是这样的。
代码1(打印后的递归调用)：
public class Test {
public static void main(String[] args) {
xMethod(5);
}
public static void xMethod(int n) {
if (n > 0) {
System.out.print(n + " ");
xM
浏览 0提问于2013-09-07得票数 0
回答已采纳
3回答
我希望有人能以“我5岁”的方式来解释这件事。
def WorryAboutMoney(money):
if (money > 3):
return print()
else:
print( money, end = " ")
WorryAboutMoney(money+1)
print( money, end = " ")
return
money = 1
WorryAboutMoney(money)
产出如下：
浏览 7提问于2020-10-15得票数 1
回答已采纳
1回答
实际上，我编写了一个递归查找两个数字的GCD的函数。我试图将递归调用的最后一个值存储到firstVal中，这样我就可以将它打印到屏幕上。我编写它的方式是打印递归的所有值。
GCD proc firstVal: dword, secondVal: dword
mov edx, 0 ;clear edx for div
cmp secondVal, 0 ;if b is 0 (only way to exit recursion)
jz foundGCD ;then a is the gcd
mov eax, firstVal ;to find a mod
浏览 3提问于2020-11-20得票数 0
为什么它先向下计数，然后再向后计数？不想改变它，只想理解它。 def bounce (n):
if n > 0:
print(n)
bounce(n-1)
print(n)
bounce(4) 结果： 4
3
2
1
0
1
2
3
4
浏览 41提问于2021-09-16得票数 0
3回答
为什么下面的代码片段不能将"1“打印到控制台？
(loop
[i 0]
(println (if (= i 0) (recur 1) i)))
相反，它在REPL中抛出了clojure.lang.ExceptionInfo: Can't recur here at line 3。这样的嵌套(recur..)语句在Clojure(脚本)中是不允许的吗？
浏览 0提问于2016-01-23得票数 2
def test(x,theList):
theList.append(x)
if x < 2:
x = x + 1
test(x,theList)
print x
print theList
test(1,[])
为什么结果是1,2？而且不仅仅是1
浏览 1提问于2012-11-19得票数 1
回答已采纳
4回答
我目前正在为二进制搜索树编写无序遍历，而我编写的函数工作正常，我有一个问题，就是我是如何递归调用这个函数的。
下面的是我编写的函数，目前使用此实现的输出是正确的。
if(root == nullptr)
return;
inorderDump(root->leftSubtree());
cout << root->value() << endl;
inorderDump(root->rightSubtree());
我的问题是，为什么这些递归调用不需要返回语句？以下与return语句完全相同的函数不起作用。
下面的是同一个函数的示例，同时使
浏览 1提问于2018-10-30得票数 1
1回答
下面是我在图中检测循环的代码：
seen = set()
def check(table,node):
seen.add(node)
#traverse all neighors of the current node
for neigh in table[node]:
print(neigh, seen)
if neigh not in seen:
check(table,neigh)
else:
return False
return True
t
浏览 3提问于2021-02-23得票数 0
回答已采纳
代码：
public static void main(String[] args) {
System.out.println(test(13549));
}
public static int test(int a){
if(a<10)
return a;
int b = (a%10);
int c = test(a/10);
int d = Math.max(b,c);
return d;
}
我理解该方法的作用(在使用调试器之后)，并且我理解该方法调用自身直到它小于10，并且它运行并检查更大的b或c。现在我不
浏览 0提问于2013-03-19得票数 0
2回答
我读到了尾递归和传统递归的区别，发现它提到“尾递归是一种不使用任何堆栈空间的递归形式，因此是一种安全使用递归的方法。”
我在努力弄明白怎么做。
用传统递归法和尾递归法求数的阶乘比较
传统递归
/* traditional recursion */
fun(5);
int fun(int n)
{
if(n == 0)
return 1;
return n * fun(n-1);
}
在这里，调用堆栈看起来就像
5 * fact(4)
|
4 * fact(3)
|
3 * fact(2)
|
浏览 2提问于2015-07-02得票数 2
回答已采纳
4回答
所以我在c中遇到了一个非常简单的问题，我想要对它做一些解释。
int function(int x)
{
switch(x)
{
case 1: return 1;
case 2: function(x-1);
case 3: return -1;
}
}
int main(){
int x = 2;
function(x);
}
当然，它非常简单，但我不明白的是。当代码执行并进入案例2时，由于没有break;，它将转到案例3，但是既然函数正在执行递归，它不应该首先遵循递归吗？
所以不，没有，输出是：
-
浏览 7提问于2017-01-23得票数 0
回答已采纳
3回答
这是我的代码：
def gcd(a,b):
if a%b == 0:
return b
print b
elif b%a == 0:
return a
print a
else:
if a > b:
gcd(a%b,b)
elif b > a:
gcd(b%a,a)
else:
return a
print a
def lcm(a,b):
if
浏览 3提问于2013-12-15得票数 1
回答已采纳
我已经对Deitel的C++问题进行了一段时间的编程和解决，当我想象这个递归函数时，我感到困惑，在这个递归函数中，一个由10个元素组成的数组和第一个元素数(current= 0)被发送到函数中。
我的问题是，在if块中执行someFunction函数之后，函数是再次返回到函数定义，还是继续执行下一个语句？
void someFunction(const array<int , arraySize>& b, size_t current)
{
if (current < b.size())
{
浏览 4提问于2021-06-27得票数 1
回答已采纳
3回答
我正在尝试使用堆栈和递归调用来实现一个队列，这是类堆栈和一些方法：
#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
class Node{
public:
int data;
Node* next;
};
Node* top = NULL;
void push(int data){
浏览 5提问于2020-01-13得票数 2
为什么即使在n= 1的情况下也存在错误堆栈？
function f(n) {
const f1 = f(n - 1);
const f2 = f(n - 2);
return n == 0 ? 0 : (n == 1 ? 1 : f1 + f2);
}
console.log(f(1));
浏览 5提问于2022-07-15得票数 -2
回答已采纳
2回答
为什么输出是那样的？
、、、、
我必须分析这些代码，我真的不明白它是如何打印出来的，而不是“！”。
#include <stdio.h>
int f(int i, int *v, char* p){
int x;
if(strlen(p)>0){
x=f(++i,v,++p);
printf("%c", *(--p)-*(v+(--i)));
}else
printf("! ");
return x;
}
int main(){
int v[4]={3,1,2,4}, a=3124;
浏览 2提问于2020-07-02得票数 0
回答已采纳
def print_numbers(n):
if n == 1:
print(n)
print("recursion over")
else:
print_numbers(n-1)
print(n)
print_numbers(10)
输出是
1
recursion over
2
3
4
5
6
7
8
9
10
为什么数字不断增加，而不是减少成负数？我知道我从来没有返回任何东西或技术上结束了代码，但这有必要吗？我只想明白这一点
浏览 6提问于2022-10-16得票数 -1
4回答
因此，我正在学习如何通过Java使用递归。我编写了一个简单的程序，它把1到n之间的所有数字相加，看起来就能完成它的工作。让我感到困惑的地方是print语句，它打印4次(针对解决方案的每个较小部分的每个结果)，如果再次调用该方法而条件尚未满足，那么它是如何到达print语句的。我理解这可以通过在主方法中创建一个int变量并将返回分配给它来解决。
public static void main(String[] args) {
int sum = recursiveCall(5);
}
public static int recursiveCall(int num) {
in
浏览 2提问于2017-07-30得票数 0
回答已采纳
3回答
请有人解释一下下面的递归方法将在堆栈中存储多少次调用，以及为什么？什么时候把东西准确地存储在堆栈中？显然是49个电话，但我不明白为什么。谢谢。
public static long fib( int n ){ // n = 50
if( n <= 1 )
return 1;
else
return fib( n - 1 ) + fib( n - 2 );
}
浏览 0提问于2015-02-25得票数 2
回答已采纳
这是我的代码：
#include<iostream>
int x;
void gad(int x)
{
if(x==0)
return;
else{
std::cout<<"geek"<<" ";
std::cout<<"for geeks ";
gad(x-1);
}
}
int main()
{
gad(3);
return 0;
}
输出如下
geek for geeks geek for geeks geek for geeks
现在，如
浏览 0提问于2020-09-04得票数 0
回答已采纳
1回答
下面是我正在使用的代码：
#include <stdio.h>
int f_b(int n, int a[n]);
int main() {
int a[4] = { 7, 6, 5, 4 };
printf("\n return: %d \n", f_b(4, a));
}
int f_b(int n, int a[n]) {
int m;
if (n == 1)
return a[0];
m = f_b(n - 1, a);
printf("m:%d", m);
if
浏览 1提问于2017-10-24得票数 0
回答已采纳
1回答
我一直在努力获取一个而不是触发器来递归地调用自己。
这样做的想法是，当一行被插入到我的表中时，触发器就会被放在上面，根据在这一点上计算的某些条件，行数据应该被修改，然后插入。同样，当满足这些条件时，应该将第二行插入到同一个表中，这也会导致触发器像以前一样触发和计算新插入的值，并修改数据和插入第二行，以此类推，直到TRIGGER_NESTLEVEL()达到特定值(始终小于3)。
尽管我可能尝试，但我似乎无法使触发器在第二次插入时再次自行执行。
下面是我编写的一些示例代码，试图说明我的问题：
--delete Tester1
--go
--drop table Tester1
alter data
浏览 0提问于2014-05-22得票数 2
回答已采纳
4回答
发现它很棘手，把我的头脑围绕递归，并将非常感谢一些洞察力。我试图理解递归中的流，方法是依次下潜一个数字乘以2。
def divide_by_2(num):
if num > 1:
divide_by_2(num // 2)
print(num)
print(num % 2,num)
divide_by_2(39)
产出：
1 1
2
0 2
4.
0 4
9
1 9
19
1 19
39
1 39
我要问的问题是
( 1)不应该先把139号印出来，为什么要把它印在最后面？为什么顺序是颠倒的？
2)应该先执行两条打印语句中的哪一条，为
浏览 0提问于2018-11-06得票数 1
回答已采纳
1回答
我的功能是把一个列表分成两半。
以下是功能：
let rec split = function
| [] -> ([],[])
| [a] -> ([a],[])
| a::b::cs -> let (M,N) = split cs
(a::M, b::N)
我不明白的是，为什么这条语句适用于(a::M, b::N)。我们不是在执行该语句之前调用递归函数吗？所以这句话不应该被执行吗？
浏览 1提问于2017-03-05得票数 3
回答已采纳
2回答
我在搜索一些答案时遇到了下面的代码。
public static void recurse(Scanner in, HashMap<String, Integer> oldMap) {
HashMap<String, Integer> map = null;
if (oldMap == null)
map = new HashMap<String, Integer>();
else
map = new HashMap<String, Integer>(oldMap);
while
浏览 0提问于2013-02-09得票数 1
回答已采纳
1回答
我试图实现置换算法。效果很好。
但是我关于这个算法中递归的问题
置换函数：
def permutations(word):
返回语句之后如何和为什么继续工作？
if len(word) == 1:
return [word]
如果最后一次击穿== '3‘如何返回到'23’从'3'回到‘23’
perms = permutations(word[1:])
char = word[0]
result = []
for perm in perms:
for i in range(len(perm
浏览 3提问于2021-10-12得票数 0
public class Main2 {
private static int[] arr = new int[3];
private static int[] values = new int[]{1, 2, 3, 4};
public static void main(String[] args) {
generateVariations(0);
}
private static void generateVariations(int index) {
if (index == arr.length) {
浏览 3提问于2017-07-23得票数 0
回答已采纳
我在Ruby中有这样一个方法：
def guess
random_guess = rand(4)
if random_guess == 0
guess
end
puts random_guess
end
guess
正如您所看到的，它的意思是在0到4之间生成一个随机数，如果这个数字是0，则会重新出现。这样做的目的是防止方法打印出0。然而，它的行为似乎并不是出于某种奇怪的原因。例如，当random_guess获得值为0时，这里是IRB中的一个示例：
2.2.0 :001 > def guess
2.2.0 :002?> random_guess =
浏览 0提问于2015-04-17得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
