了解递归调用循环的工作方式

Question

I'm really new to recusivity, and i stumbled across an exercise in which we have a loop making several recursive calls, and i did not understand, how it is working.

Look at the example below :

int calculateSomething (int n) {

 if (n > 100)
  for (int i = 0; i < 10; i++)
   calculateSomething(n+1);
}

Suppose i make a first call to calculateSomething(200), how many calls i'm gonna have ? At first glimpse i would say 100*10, so 1000 calls ?

Does "i" goes along way to 10 for each call ? Or it makes a call for each value of "i" ?

I'm sorry to ask such a question but i'm really blocked XD

Thanks in advance !

Answer 1

First of all, your example code will lend on an infinite loop, if( n>100 ) will be avaluated as TRUE on all your recursive calls because your "n" value always increase. calculateSomething(n+1)

If you call calculateSomething(200) , the first recursive call will be inside the for loop with i=0 , CalclulateSomething(201)

Then forget about the next iterations of the for loop until the recursive call ends , and as I explained before, it will never happen.

calculateSomething(200)
  -> i=0 calculateSomething(201)
    -> i=0 calculateSomething(202)
      -> i=0 calculateSomething(203)
        -> ...infinite...

Take the next code as example: (Fixed the infinite loop, and reduced the values for explanation)

int calculateSomething (int n) {

 if (n < 3)
  for (int i = 0; i < 3; i++)
   calculateSomething(n+1);
}

The recursive calls will be:

calculateSomething(0)
  -> i=0 calculateSomething(1)

    -> i=0 calculateSomething(2)

       -> i=0 calculateSomething(3)
         -> end. if (n < 3) = FALSE
       -> i=1 calculateSomething(3)
         -> end. if (n < 3) = FALSE
       -> i=2 calculateSomething(3)
         -> end. if (n < 3) = FALSE

     -> i=1 calculateSomething(2)

       -> i=0 calculateSomething(3)
         -> end. if (n < 3) = FALSE
       -> i=1 calculateSomething(3)
         -> end. if (n < 3) = FALSE
       -> i=2 calculateSomething(3)
         -> end. if (n < 3) = FALSE

     -> i=2 calculateSomething(2)

       -> i=0 calculateSomething(3)
         -> end. if (n < 3) = FALSE
       -> i=1 calculateSomething(3)
         -> end. if (n < 3) = FALSE
       -> i=2 calculateSomething(3)
         -> end. if (n < 3) = FALSE

  -> i=1 calculateSomething(1)

     -> i=0 calculateSomething(2)

       -> i=0 calculateSomething(3)
         -> end. if (n < 3) = FALSE
       -> i=1 calculateSomething(3)
         -> end. if (n < 3) = FALSE
       -> i=2 calculateSomething(3)
         -> end. if (n < 3) = FALSE

     -> i=1 calculateSomething(2)

       -> i=0 calculateSomething(3)
         -> end. if (n < 3) = FALSE
       -> i=1 calculateSomething(3)
         -> end. if (n < 3) = FALSE
       -> i=2 calculateSomething(3)
         -> end. if (n < 3) = FALSE

     -> i=2 calculateSomething(2)

       -> i=0 calculateSomething(3)
         -> end. if (n < 3) = FALSE
       -> i=1 calculateSomething(3)
         -> end. if (n < 3) = FALSE
       -> i=2 calculateSomething(3)
         -> end. if (n < 3) = FALSE

   -> i=2 calculateSomething(1)

     -> i=0 calculateSomething(2)

       -> i=0 calculateSomething(3)
         -> end. if (n < 3) = FALSE
       -> i=1 calculateSomething(3)
         -> end. if (n < 3) = FALSE
       -> i=2 calculateSomething(3)
         -> end. if (n < 3) = FALSE

     -> i=1 calculateSomething(2)

       -> i=0 calculateSomething(3)
         -> end. if (n < 3) = FALSE
       -> i=1 calculateSomething(3)
         -> end. if (n < 3) = FALSE
       -> i=2 calculateSomething(3)
         -> end. if (n < 3) = FALSE

     -> i=2 calculateSomething(2)

       -> i=0 calculateSomething(3)
         -> end. if (n < 3) = FALSE
       -> i=1 calculateSomething(3)
         -> end. if (n < 3) = FALSE
       -> i=2 calculateSomething(3)
         -> end. if (n < 3) = FALSE

If you want to calculate the number of times your function is called, you can simply add a conunter and increment it for every call, something like:

int counter = 0;  // declaring it on a global scope

int calculateSomething (int n) {

    counter++;

    if (n < 3)
      for (int i = 0; i < 3; i++)
       calculateSomething(n+1);
    }

Answer 2

The program you had given does not have a return statement even though return type is int. Moreover it will go on infinitely because there is no end condition.

This would be the execution cycle

call 1: n=200 i=0 calculateSomething(201)

call 2: n=201 i=0 calculateSomething(202)

call 3: n=202 i=0 calculateSomething(203) ....

Does "i" goes along way to 10 for each call ? Or it makes a call for each value of "i" ?

Makes a call for each value of i. Recursion works with a stack (Last in First out). In simple program say I call Method1 from main and Method2 from Method1, the stack that would look like this

Method2

Method1

main

Basically the last one called will be at the top and once that completes it will go to next one.

Since you are new to this start with a simpler example like factorial

public static int factorial(int n) {
    if (n == 0) {
        return 1;
    } else {
        System.out.println(n + " "+ (n-1));
        return n * factorial(n - 1);
    }
}

If you call factorial(3) then stack would look like

1 (since factorial(1-1) ie factorial(0) is 0)

1 * factorial(1-1)

2 * factorial(2-1)

3 * factorial(3-1)

factorial(3) ---> the actual method call

Now every time a call returns here it will replace the factorial(n-1) in the one below it with the actual value ie

factorial(1-1) will be replaced by 1

factorial(2-1) will be replaced by 1 * 1

factorial(3-1) will be replaced by 2 * (1 * 1)

factorial(3) becomes 3 * (2 * (1 * 1))

Hope this helps.