Question

以下是一个使用递归返回数字反转的函数。但是，它只返回数字的最后一位数字。我想知道为什么以及如何解决它？

int rev(int number)
{
      int revNum=0, sum=100;

      if(number<=9) return(number);
      else if(number>0) 
      {
           return(rev(number/10)+revNum);
           revNum=(number%10)*sum; sum=sum/10;

      }
}

谢谢!!!

Answer 1

这是一些有效的代码：

int rev (int number){
    int base = 1;

    while (number / (base * 10)){/*
        * This calculates the base of the number
        * ie number = 435
        *    base   = 100
        */
        base *= 10;
    }

    if (number <= 9){
        return number;
    } else if (number >= 10){ // notice different expression
        int revNum = (number % 10) * base; // this was out of order
        return rev (number / 10) + revNum;
    }
}

除了我上面评论的内容之外，您的代码无法工作的主要原因是sum未在调用中保留。这是制作递归函数时的常见问题。

为了解决这个问题，每个函数调用计算“基数”，而不是固定值。这也有点好，因为它允许传递更大的数字，而不是大于100的数字（你选择的代码的另一个限制）。

另一个实现是将base作为第二个参数，这样就不必每次调用函数都重新计算它。但是，这可以通过简单的宏轻松解决。电话可能是：

int rev_number (int number, int base){ .. }

但是a可以方便地放在宏（或其他函数调用）中：

#define rev(num) rev_number (number, 0)

效率稍高，但差异可能重要，也可能不重要。

Answer 2

这是解决方案。

将以下功能称为reverse (number, 0);

int reverse(long int n, long int rev) {
    if(n == 0)
        return rev; 
    return reverse(n / 10, rev * 10 + n % 10);
}

Answer 3

int rev(int num){
    return num < 10 ? num : (num % 10) * pow(10, (int)log10(num)) + rev(num/10);
}

它在一行中完成。

Answer 4

嗨小的修正你的代码返回输入数字的第一个数字（不是最后一个数字）。这就是原因

您在返回某个值后计算revNum

    return(rev(number/10)+revNum);
    revNum=(number%10)*sum; sum=sum/10;

因此第二个陈述没有效果。

另外 revNum 是一个局部变量

因此，每次调用递归函数时，都会创建 sum （局部变量）和revNum的新本地副本，并分别使用0和100进行初始化。

您的递归树看起来像这样，例如 596 是传递给递归函数的数字。

              rev(596) //call from main
              rev(59)-->rev(5) // these are recursive calles

现在rev（5）将5（从5＆lt; 9）返回给调用者，即从那里返回到（59）到主调用者，从而得到第一个数字的显示，在这种情况下是5。

如何解决？

要解决这个问题，你必须使它们成为全局变量（sum和revNum），并且在计算反向数后，return语句应该在最后。这是简单的代码。

我将反向变量设为全局以保留其中的更改，最后我将其返回给调用者。

    #include <stdio.h>
    int reverse;           //globally declared
    int rev(int revNum)
    {
       if(revNum)
       {
          reverse = (reverse * 10) + (revNum % 10);
          rev(revNum/10);    //recursive call 
       }
       else              
        return;    //return back to caller when revNum becoms 0
    return reverse;          
    }

   int main()
   {
       int num;
       printf("Enter a number:");
       scanf("%d",&num);
       printf("Reverse Number is:%d\n",rev(num));
       return 0;
   }

Answer 5

  /* This is a simple beginner question so i think we need to write a simple code to answer it too.
Here is my answer. In this way we don't need to create new variables.
  n%10 gives us the last number,first we print 
  the last one and then we call reverse function
  again but now with parameter n/10 so we get 
  rid of last number which is already printed */

    int reverse(int n)
{
    if(n<10)
        printf("%d",n);
    else
    {
        printf("%d",n%10); 
        reverse(n/10);
    }
}

Answer 6

可能是这个片段有帮助：

//init reversed number with last digit of number
reversed_number=number % 10;
//remove the last digit of number
number=number / 10;

//if number has another digit...
while (number > 0)
{
    //...shift left all digits of the reversed_number by one digit
    //    and add the last digit of number
    reversed_number=reversed_number*10+(number % 10);
    //remove the last digit of number
    number=number / 10;
}

......稍后补充......

递归变体看起来像这样（我使用两个函数来获得所需的签名）：

int rev(int number)
{
    return rev_ext(0,number);
}

int rev_ext(int result, int number)
{
    if (number<10)
    {
        return result*10+number;
    }
    else
    {
        result=result*10 + number % 10;
        return rev_ext(result, number / 10);
    }
}

我确信它可以写得更短/优化; - ）

*斯特

Answer 7

这是递归解决方案：

#include <stdio.h>
#include <string.h>

main()
{
   int pow(int a, int b){
        int p = 1;
        while(b){
            p = p * a;
            b--;
        }
        return p;
    }

    int len(int number) {
        int i = 0;
        while (number) {
            number/=10;
            i++;
        }
        return i;
    }

    int rev(int number) {
        int revNum=0;
        int i = len(number) - 1;

        if(number<=9) {
            return number;
        } else {
            return(number%(10)*pow(10,i) +rev(number/10));
        }
    }
    printf("%d",rev(1234));
}

Answer 8

检查此递归版本。

#include <stdio.h>  
#include<math.h>
int main()                                                  
{
  int n=345;
  printf("%d",rev(n));
}
int len(int number) 
{
  int i;
  for(i=0;number>0;number=number/10,i++);
  return i;
}
int rev(int n)
{
   if (n==0) return 0;
   int val=0;
   val=n%10;
   return (val * pow(10,len(n)-1)+rev(n/10));
}

反向数字函数使用C中的递归

8 个答案: