Can Recursion be named as a simple function call?

问题

Please consider an Recursive function :

 1)   int calc(int num)
       {

 2)    sum=sum+num;//sum is a global variable

 3)    num--;

 4)    if(num==0)
 5)    return sum;

 6)    calc(num);

       }

It calculates the sum of an integer . My teacher told me it's not recursion, but a simple function call, because you need to pass num-- as an argument and return calc(num--) .

I was shocked, as I knew only one thing when a function call itself, its recursion.

She also gave the reason, that line no. 2 and 3 is stored extra in stack memory. I have no idea what she was referring to.So after going through stack storage thingy:

Here, I noticed that the function arguments passed are in a recursive way, like n-- in my function. So that they can be linked to the next function call.

For just this sake, can we term it a simple function call instead of recursion?

回答1:

The teacher has something quite specific in mind even though what you presented is, technically, recursive. Another form which wouldn't depend upon the global would look something like this:

int calc(int num)  // Assume this is valid for non-negative numbers
                   // In that case, type "unsigned int" would be more appropriate
{
    if ( num < 0 )
        return -1;  // Consider this an error; won't happen in recursive case

    if ( num == 0 )
        return 0;

    return num + calc(num-1);
}

回答2:

You are correct, recursion is a function that calls itself. PERIOD. There are other points worth separately discussing about global variables, and other good programming practices, but whether you implement the decrement operator in the line of code where you call the function recursively or prior to that point, you are still making a recursive call.

回答3:

It looks like you're trying to calculate, for a given num, the sum of 0 to num. The calc function really just needs one argument, num, and can then call a helper function calc_num which takes the current number and the running sum:

int calc( int num ) {
  return calc_help( num, 0 );
}

Then, calc_help, given a current number, and the sum so far, checks whether num is less than or equal to zero. If it is, then the current running sum is the final sum and can be returned. Otherwise, a recursive call to calc_help is made. The current number for it will be one less than num (so that we're calling calc_help with successively smaller first arguments, getting closer and closer to the case where num <= 0), and the current sum will be sum plus the current number:

int calc_help ( int num, int sum ) {
  return num <= 0 ? sum : calc_help( num-1, sum+num );
}

In a language (like Scheme) that performs tail call optimization, this is essentially the following loop. Some C/C++ compilers do perform tail call optimization (e.g., according to Tail recursion in gcc/g++, GCC will optimize tail calls when -O2 is specified), so this isn't entirely a moot point.

int calc( int num ) {
  int sum = 0;
  while ( num > 0 ) {
    sum = sum+num;
    num = num-1;
  }
  return sum;
}

or (if you want to be a bit more obscure):

int calc( int num ) {
  int sum = 0;
  for ( ; num <= 0; sum+=num, num-- );
  return sum;
}

The more naïve recursive implementation that performs the addition of after the recursive call, i.e.,

int calc( int num ) {
  return num <= 0 ? num : num + calc( num-1 );
}

can't be optimized in this way.

来源：https://stackoverflow.com/questions/19865503/can-recursion-be-named-as-a-simple-function-call

标签

recursion

function-calls