如何实现此递归行以打印反向字符串？

Question

Shortly, I need to know how this function works? What's go inside? How is the passed string reversed?

Here is the code and thanks in advance.

#include <stdio.h>
void rev (const char* const);

int main()
{
    char str [] = "Hey There";
    rev(str);

    return 0;
}

void rev(const char* const c)
{
    if(c[0]=='\0')
        return ;
    else
    {
        rev( &c[1]);
        putchar(c[0]);
    }
}

EDIT: As the commenters advised, I will explain what I'm not understanding more. The string is not reversed, but printed reversely, Ok fine. What is the mechanism used to do this? what is the execution sequence?

Answer 1

The reason is that the code dictate it to do the rest of the string before processing outputting the current char. Imagine the string "on\\0"

rev("on\0");
  ->rev("n\0");
    ->rev("\0");  
      <-return;   // hits base case
    putchar('n'); // resumes after recursive call
    <-return;     // invisible return at end of function
  putchar('o');   // resumes after recursive call
  <-return;       // invisible return at end of function

Every identation here represents a nested call. Thus at the base case you have 3 calls to rev going at the same time, each with different c .

Its important to know that c is unique for each invocation so that when a call to rev returns to a previous rev c has not changed in the callee. That makes it nothing special so in fact it works the same way as calling a different function each time that does the same. It resumes after the previous call has returned.

Answer 2

Actually this recursive function is not reversing the input string. It is just printing it in reversed order. The logic is simple- Suppose I am having string str[4] = "ABC" which is null terminated string in C.

• For first call to rev(str) - str[0] is 'A' which is not null --> call rev(str[1]) and print str[0] = 'A'
• For second call to rev() str[0] is 'B' which is not null --> call rev(str[1]) and print str[0] = 'B'
• And so on till '\\0' is found.

Now before returning from each function call it is printing str[0]-

• So for '\\0' - It will simply return without printing anything.
• For 'C', it will print 'C'
• For 'B', it will print 'B' And so on.

So the string will be printed in reverse order.

Answer 3

As per your program, ** H eythere ** ,In rev function,

1. c[0] = H is checked as NULL or not ==> NO
2. Passing address &c[1] = "ey there" which starts from e to again to rev function.
3. c[0] = e is checked as NULL or not ==> NO
4. Passing address &c[1] = "y there" which starts from y to again to rev function.
5. this logic continues till end.
6. c[0] = e is checked as NULL or not ==> NO
7. Passing address &c[1] = \\0 which is NULL character to be passed to rev function.
8. once identified \\0 , rev function starts returning.
9. after rev function, we have putchar(c[0]) which prints latest value of c[0] as 'e' [as per point 6].
10. the print continues ereh T ye H

Answer 4

To make the action of the function more clear rewrite it the following way

void rev( const char * const s )
{
    if ( s[0] != '\0' )
    {
        char c = s[0];
        rev( s + 1 );
        putchar( c );
    }
}

So for the first call of the function the function stores the first character of the string in the variable c .

Then the function is called the second time moving the pointer to the second character. Again the function stores this character in its own (local) variable c .

And so on until the terminating zero is encountered.

Then each function invocation before passing the control to the calling invocation prints its character stored in the variable c and you get the reverse order of the characters of the string.

Answer 5

As you have mentioned, it is a recursive function. So the execution goes like this

From main(), rec() is called. The control now enters the rec() function. Where a condition check is made to detect the end of string. Until the end of string is detected, else part gets executed.

Now let us see what happens in else part.

else calls rec() again. Where the rec() is called again until the end of string is met.

so the call sequence goes like this->

main()-> rec()->rec(rec(rec(... until \0..) putchar()) putchar())putchar())

So on end of the control from last rec() function last putchar() will be executed. Then on the last before on and goes on till the first rec() called from main() .

main() -> rec(H) as it is not null -> it again calls rec(e)

Here the control has not came out of the first call to rec() . So rec(H) looks like

rec(H)
{
rec(e);
putchar(H);
}

it goes on like this