我需要关于下一次递归的解释（我是初学者）

Question

I know that lowkey it does 1 + 2 + 3 + 4 = 10, but I want to know how exactly it does that

public class Main {

    public static int sum(int n) {
        if(n == 0) return 0;
        return sum(n - 1) + n;
    }
    
    public static void main(String[] args) {

    System.out.println(sum(4));
    
    }//main 
    
}//class

Answer 1

public static int sum(int n) {
    if(n == 0) return 0;
    return sum(n - 1) + n;
}

When you call sum(4) , the compiler does the following steps:

1. sum(4) = sum(3) + 4, sum(3) then calls sum(int n) and go to next step
2. sum(3) = sum(2) + 3, sum(2) then calls sum(int n) and go to next step
3. sum(2) = sum(1) + 2, sum(1) then calls sum(int n) and go to next step
4. sum(1) = sum(0) + 1, sum(0) then calls sum(int n) and go to next step
5. sum(0) = 0, return the value and bring it to previous step.

Then with backtracking, the compiler brings the value of sum(0) to the formula sum(0) + 1 , so the value of sum(1) is 1. And so on, finally we get sum(4) is 10.

Answer 2

The key to understanding how this recursion work is the ability to see what is happening at each recursive step. Consider a call sum(4) :

return
    sum(3) + 4
    sum(2) + 3
    sum(1) + 2
    sum(0) + 1
    return 0 in next recursive call

It should be clear how a sum of 10 is obtained for sum(4) , and may generalize to any other input.

Answer 3

Okay so lets understand it:

1. you call the method from main method passing the argument as 4.
2. It goes to method, the very first thing it checks is called as base condition in recursion. Here base condition is if n == 0 return 0.
3. We skipped the base condition since n is not yet zero. we go to return sum(n-1)+n that is sum(4-1)+4 . So addition will not happen, because you made the recursive call again to sum method by decrementing the n value to n-1, in this case it is 3.
4. You again entered the method with n =3, check the base condition which is not valid since 3,= 0, so we go to return sum (n-1)+3 , which is sum(3-1)+3
5. Next recursive call where n = 2, base condition is not valid 2,=0 , so we return sum(n-1)+2that is sum(2-1)+2 .
6. Next call with n = 1, base condition is not valid, we go to return sum(n-1)+1 that is sum(1-1)+1 .
7. Next recursive call with n = 0, so now base condition is met, means it is time to stop the recursion and keep going back to from where we came to get the desired result. So this time we returned 0 .
8. Lets go back to step 6, with 0 we got and compute the addition part of sum(1-1)+1. You got sum(1-1) => sum(0) =. So sum(1-1)+1 will be equal to 0+1=1
9. One more step back with 1 as value to step 5, where we have sum(2-1)+2 = sum(1)+2 , sum(1) you know, which is 1, so we will return 1+2=3 from this recursive call.
10. One step back with value as 3, to step 4, sum(3-1)+3 = sum (2)+3 = 3+3 =6 .
11. Going one step back with 6 as value to step 3, sum(4-1)+4 = sum(3)+4 = 6+4 = 10 . And that is where we started from. You got the result as 10.

Answer 4

Recursion itself is very easy to understand.
From a mathematical point of view, it is just a simple function call, such as your code:

public static int sum(int n) {
    if(n == 0) return 0;
    return sum(n - 1) + n;
}

/*
sum(0) = 0
sum(1) = 1
sum(n) = n + sum(n-1)
*/

In fact, the concept of recursion has been introduced in high school. It is the "mathematical construction method" that is often used to prove sequence problems. The characteristics are obvious: the structure is simple and the proof is crude. As long as you build the framework, you can prove it in conclusion. So what is a recursive "simple structure" framework?

• Initial conditions: sum(0) = 0
• Recursive expression: sum(n) = sum(n-1) + n
  

And in fact about the sum() function, every calculation starts from sum(0) , and it is natural. Even if you are asked to calculate sum(1000), all you need is paper, pen, and time, so recursion itself is not difficult.
So why recursion give people an incomprehensible impression? That's because "recursive realization" is difficult to understand, especially using computer language to realize recursion. Because the realization is the reverse, not to let you push from the initial conditions, but to push back to the initial conditions, and the initial conditions become the exit conditions.

In order to be able to reverse the calculation, the computer must use the stack to store the data generated during the entire recursion process, so writing recursion will encounter stack overflow problems. In order to achieve recursion, the human brain has to simulate the entire recursive process. Unfortunately, the human brain has limited storage, and two-parameter three-layer recursion can basically make you overflow.

Therefore, the most direct way is to use paper to record the stacks in your head. It is very mechanically painful and takes patience, but problems can often be found in the process.

Or, go back to the definition of recursion itself.

First write the architecture and then fill it in. Define the exit conditions and define the expression.
Second implement the code strictly according to the architecture. Recursive code is generally simple enough, so it is not easy to make mistakes in implementation. Once there is a problem with the program result, the first should not be to check the code, but to check your own definition.
Meeting Infinite loop? The initial conditions are wrong or missing; wrong result? There is a problem with recursion. Find out the problem, and then change the code according to the new architecture. Don't implement it without clearly defining the problem.

Of course, it really doesn't work. There is only one last resort: paper and pen.