难以理解连续的递归调用

Question

I am trying to understand the following program in which successive recursion function calls are present, but getting confused while tracing how the tack gets loaded.

void func(char*);  // function prototype

int main(){
    func("123");
    return 0;
}

void func(char a[]){
    if(a[1]=='\0')
        return;
    func(a+1);
    func(a+1);
    printf("%c",a[1]);
}

the output for this is 3 3 2

would appreciate if someone could advise on this one...

does this kind of multiple recursive calls beneficial in any way or find application in specific problem areas..?

Answer 1

Just put yourself in the position of the CPU and step through line-by-line (or use a debugger to help with that task).

The first call is to

func("123")

this call does not satisfy the termination condition a[1] == '\\0' , so it calls

func("23");

The call to func("23") in turn calls

func("3")

which DOES satisfy the return condition. So, that call returns to the previous caller, func("23").

func("23") proceeds to make another call to func("3") due to the lines

func(a+1);
func(a+1);

Continue this process of executing the program in your mind, and write down what would be in each call to printf . That will explain your output.

UPDATE

Note that the call to printf() happens after the recursive calls, so eg a call to

func("123")

would proceed like

• Enter func("123")
• Termination condition not met
• Call func("23")
• Call func("23") again
• Printf("3") (which is a[1])
• Return

Answer 2

the posted code is a rather poorly designed instance of recursion.

The following code has the correct 'tail' form of recursion.

It could be made even better by passing the reversed string back to main and let main print it.

It reverses the order of the string passed to func() by main()

Please, when asking about a runtime problem, post code the compiles, including the necessary #includes for header files so we are not guessing about which headers to include

#include <stdio.h>

void func(char*);  // function prototype

int main(){
    func("123");
    return 0;
}

void func(char a[])
{
    if(a[1]=='\0')   // check for end of recursive sequence
    {
        printf( "%c", a[0] ); // last tail action
        return;
    }

    func(a+1);    // step+next recursion
    printf( "%c", a[0] ); // tail action
    return;
}

Answer 3

Debugging with breakpoints is one way to understand recursion. Another way is to draw the tree of recursive calls.

From the figure, In every level after level0, the printf statement occurs after every two nodes owing to these two lines of code:

func(a+1);
func(a+1);

In general, this becomes a perfect binary tree for any input string of length greater than 0. The total number of nodes is given by this formula:

2^(k+1) - 1 // k is the depth; here k = 2

Total number of printf statements executed can be obtained by this formula:

2^k - 1 // For k=2, there will be 3 printf statements each printing 3,3,2 respectively

Answer 4

The recursion can be simply understood as follows.

For example:

Func(int a){
    while(a>1)
        return a * func(a-1);
}

Suppose a = 5 .

What happens is that it returns 5 * func(4) .

Now func(4) returns 4 * func(3) and it goes on like this.

Check out this example for use of recursion in fibonacci series .