在java中递归地添加到字符串

我试图在java中将INT123转换为字符串“CBA”

我知道我在递归中有一些误解

在多次println声明之后，我知道

ss将成为“CBA”

但它会返回“CB”和“C”

我知道递归会像这样工作，但我不知道如何修复它

谁能帮我写代码，谢谢

public String recur ( int x, String ss )
{
    if ( x >= 1 && x < 10 )
        ss = ss + "A";

    if ( x >= 10 && x < 100 )
    {
        ss = ss + "B";
        recur( x % 10, ss);
    }

    if ( x >= 100 && x < 1000 )
    {
        ss = ss + "C";
        recur( x % 100, ss);    
    }
return ss;          

公共字符串重现（int x，字符串ss）
{
如果（x>=1&&x<10）
ss=ss+A；
如果（x>=10&&x<100）
{
ss=ss+“B”；
复发（x%10，ss）；
}
如果（x>=100&&x<1000）
{
ss=ss+“C”；
复发（x%100，ss）；
}
返回ss；

您忽略了recur的返回值，因此在输出端只能看到第一级递归

因此，您可以这样做以考虑返回值。（只需将recur的输出分配给ss）

还有另一个电话

ss = recur( x % 100, ss);

---

您的方法是不正确的，对于初学者来说，您甚至不需要将字符串作为参数传递—只需在返回值中构建字符串即可。此外，从整数转换为字符串的逻辑过于复杂，仅当整数包含的数字

1、2、3

的顺序正好相同时才有效！下面是一种更简单、有效的方法依次处理每个字符并适用于任何数字的整数：

public String recur(int x) {
    if (x <= 0)
        return "";
    return (char) (x % 10 + 'A' - 1) + recur(x / 10);
}

公共字符串重现（int x）{
如果（x（这个答案主要是针对花生画廊…）

以下是我对该问题的“最佳”递归解决方案的看法：

public String recur ( int x )
{
    if ( x >= 1 && x < 10 ) {
        return "A";
    } else if ( x >= 10 && x < 100 ) {
        return "B" + recur( x );
    } else if ( x >= 100 && x < 1000 ) {
        return "C" + recur( x );    
    } else {
        throw new IllegalArgumentException();
    }
}

System.err.println(recur(123));

公共字符串重现（int x）
{
如果（x>=1&&x<10）{
返回“A”；
}如果（x>=10&&x<100），则为else{
返回“B”+重复出现（x）；
}否则，如果（x>=100&&x<1000）{
返回“C”+重复出现（x）；
}否则{
抛出新的IllegalArgumentException（）；
}
}
系统错误println（重现（123））；

或者更一般地说：

public String recur ( int x)
    return recur0( x, 0 );
}

public String recur0 ( int x, int i )
{
    if ( x <= 0 ) {
        return "";
    else {
        return recur0( x % 10, i + 1 ) + ((char) ('A' + i));
    } 
}

System.err.println(recur(123));

公共字符串重现（int x）
返回递归0（x，0）；
}
公共字符串递归0（整数x，整数i）
{
如果（x），即使Java允许，重用方法参数值也是不好的做法。提示：使用
StringBuilder
。请注意，尽管@fge的注释是正确的，但它无助于解决OP的问题。还有“提示”非常值得怀疑。它充其量只是一个边缘微优化。如果OP关注性能，那么正确的优化应该是迭代实现…@StephenC我不会将保证数据安全的东西称为“微优化”@fge-使用StringBuilder如何“保证数据安全”？你到底在说什么“数据安全”？这里的问题是代码的正确性、健壮性和可读性，而不是“数据安全”。@StephenC很简单：stringbuilder上的任何优化都会影响stringbuilder本身；因此，你可以递归并将其作为参数传递，然后返回
sb.toString（）
作为参数。这与不可变的
字符串不同。谢谢，对了，我想我忽略了一些我已经更改过的内容recur（x%10，ss）；改为ss=recur（x%10，ss）…但我仍然只得到了C。你两次重复呼叫都这么做了吗？我想not@user2442300如果答案对你有帮助，那么OP的解决方案只有在整数包含数字1、2或3时才有效——这不够一般，对于任何包含不同数字的数字都会失败@ÓscarLópez——我想我们都是对的唱一唱真正的问题陈述是什么。当然，你不能从一个例子中推断出来……也不能从解决问题的失败尝试中推断出来
public String recur ( int x)
    return recur0( x, 0 );
}

public String recur0 ( int x, int i )
{
    if ( x <= 0 ) {
        return "";
    else {
        return recur0( x % 10, i + 1 ) + ((char) ('A' + i));
    } 
}

System.err.println(recur(123));

public void recur ( int x, StringBuilder sb )
{
    if ( x >= 1 && x < 10 ) {
        sb.append("A");
    } else if ( x >= 10 && x < 100 ) {
        sb.append("B");
        recur( x, sb );
    } else if ( x >= 100 && x < 1000 ) {
        sb.append("C");
        recur( x, sb );    
    } 
}

StringBuilder sb = new StringBuilder();
recur(123, sb);
System.err.println(sb.toString());

public String nonRecur(int x) {
    if ( x >= 1 && x < 10 ) {
        return "A";
    } else if ( x >= 10 && x < 100 ) {
        return "BA";
    } else if ( x >= 100 && x < 1000 ) {
        return "CBA";    
    } else {
        throw new IllegalArgumentException();
    }
}

System.err.println(nonRecur(123));