Java 使用递归在不使用字符串的情况下反转整数

我已经试了一段时间了，但是没能成功。我正在尝试一种不使用字符串或数组来反转整数的方法。例如，123应以整数形式反转为321

我的第一次尝试：

/** reverses digits of integer using recursion */
public int RevDigs(int input)
{
    int reverse = 0;
    if(input == 0)
    {
        return reverse;
    }
    int tempRev = RevDigs(input/10);
    if(tempRev >= 10)
        reverse = input%10 * (int)Math.pow(tempRev/10, 2) + tempRev;
    if(tempRev <10 && tempRev >0)
        reverse = input%10*10 + tempRev;
    if(tempRev == 0)
        reverse = input%10;   
    return reverse;
}//======================

/**使用递归反转整数的位数*/
公共整数RevDigs（整数输入）
{
int反向=0；
如果（输入==0）
{
反向返回；
}
int tempRev=RevDigs（输入/10）；
如果（tempRev>=10）
反向=输入%10*（int）数学功率（tempRev/10，2）+tempRev；
如果（临时版本0）
反向=输入%10*10+tempRev；
如果（tempRev==0）
反向=输入%10；
反向返回；
}//======================

我也试着用这个，但它似乎弄乱了中间的数字：

/** reverses digits of integer using recursion */
public int RevDigs(int input)
{
    int reverse = 0;
    if(input == 0)
    {
        return reverse;
    }
    if(RevDigs(input/10) == 0)
        reverse = input % 10;
    else
    {
        if(RevDigs(input/10) < 10)
            reverse = (input % 10) *10 + RevDigs(input/10);
        else
            reverse = (input % 10)* 10 * (RevDigs(input/10)/10 + 1) + RevDigs(input/10);
        }
    return reverse;
}

/**使用递归反转整数的位数*/
公共整数RevDigs（整数输入）
{
int反向=0；
如果（输入==0）
{
反向返回；
}
如果（转速（输入/10）==0）
反向=输入%10；
其他的
{
如果（转速（输入/10）<10）
反向=（输入%10）*10+旋转（输入/10）；
其他的
反向=（输入%10）*10*（RevDigs（输入/10）/10+1）+RevDigs（输入/10）；
}
反向返回；
}

我曾尝试在网站上查看一些示例，但我无法让它们正常工作。为了进一步澄清，我不能在这个项目中使用字符串或数组，必须使用递归。有人能帮我解决这个问题吗。多谢各位

那么：

public int RevDigs(int input) {
    if(input < 10) {
        return input;
    }
    else {
        return (input % 10) * (int) Math.pow(10, (int) Math.log10(input)) + RevDigs(input/10);
        /* here we:
           - take last digit of input
           - multiply by an adequate power of ten
             (to set this digit in a "right place" of result)
           - add input without last digit, reversed
        */
    }
}

public int RevDigs（int输入）{
如果（输入<10）{
返回输入；
}
否则{
返回（输入%10）*（整数）数学功率（10，（整数）数学日志（输入））+RevDigs（输入/10）；
/*在这里，我们：
-取输入的最后一位
-乘以十的适当幂
（将此数字设置在结果的“正确位置”）
-添加不带最后一位的输入，反转
*/
}
}

---

当然，这假设

input>=0

。

使用递归的关键是要注意，您试图解决的问题包含同一问题的较小实例。在这里，如果您试图反转数字13579，您可能会注意到，您可以通过反转3579（相同的问题，但更小），将结果乘以10，再加上1（您取下的数字），使其成为一个较小的问题。或者你可以将数字1357倒转（递归），得到7531，然后在结果上加9*（10的幂）。第一件棘手的事情是，你必须知道何时停止（当你有一个1位数的数字时）。第二件事是，对于这个问题，你必须计算出数字的位数，这样你才能得到10的幂。您可以使用

Math.log10

，也可以使用循环，从1开始乘以10，直到它大于您的数字。

使用两种方法如何

public static long reverse(long n) {
    return reverse(n, 0);
}

private static long reverse(long n, long m) {
    return n == 0 ? m : reverse(n / 10, m * 10 +  n % 10);
}

public static void main(String... ignored) {
    System.out.println(reverse(123456789));
}

印刷品

987654321

---

很抱歉，问题需要重新格式化，我的代码没有正确显示，我将修复您使问题过于复杂的问题。我看不出有任何理由需要在

if

中进行递归调用。它可能会工作，但肯定很难遵循，而且看起来可能会出错。当输入843时，它返回78，因此它没有按计划工作。谢谢，工作正常，很抱歉延迟，我正在学习。Math.pow非常昂贵。你不需要那么复杂的东西，看看我的答案。我明白了，两种方法都很好用，但是为了方便起见，我只使用上面的一种方法，因为我目前不担心内存，因为我的程序就是这么做的，而且是斐波那契序列，但是谢谢你的建议，我会在以后的工作中考虑到这一点future@PeterLawrey当然谢谢你指出这一点。Hovewer，这个任务显然不是为了提高效率，这就是为什么我提出了一个使用算法的解决方案，这个算法更容易理解。是的，不允许循环，我们在课程中根本没有使用对数，所以我不相信这是老师想要的。@Abymaldan:如果你不能使用Java的

Math.log10

，写你自己的，从

RevDigs

直接调用它。它需要循环，但我怀疑这是否重要，因为它不直接在递归中。如果你根本不能使用循环，你可以编写一个单独的递归例程来计算位数<代码>如果n<10返回1，否则返回1+numberOfDigits（n/10）。请详细说明并解释您的建议。请尽量避免将代码作为答案，并尝试解释它的作用和原因。对于没有相关编码经验的人来说，您的代码可能并不明显。请编辑您的答案以包括

package Test;

public class Recursive {
    int i=1;
    int multiple=10;
    int reqnum=0;
    public int recur(int no){
        int reminder, revno;

        if (no/10==0) {reqnum=no;
        System.out.println(" reqnum "+reqnum);
        return reqnum;}
        reminder=no%10;
        //multiple =multiple * 10;
        System.out.println(i+" i multiple "+multiple+" Reminder "+reminder+" no "+no+" reqnum "+reqnum);
        i++;

        no=recur(no/10);
        reqnum=reqnum+(reminder*multiple);
        multiple =multiple * 10;
        System.out.println(i+" i multiple "+multiple+" Reminder "+reminder+" no "+no+" reqnum "+reqnum);
        return reqnum;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int num=123456789;

        Recursive r= new Recursive();
        System.out.println(r.recur(num));
    }

}

import java.io.*;

public class ReversalOfNumber {
    public static int sum =0;
    public static void main(String args []) throws IOException
    {
        System.out.println("Enter a number to get Reverse & Press Enter Button");
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String input = reader.readLine();
        int number = Integer.parseInt(input);
        int revNumber = reverse(number);
        System.out.println("Reverse of "+number+" is: "+revNumber);
    }
    public static int reverse(int n)
    {       
        int unit;
        if (n>0)
        {
            unit = n % 10;
            sum= (sum*10)+unit;
            n=n/10;
            reverse(n);
        }
        return sum;
    }
}