Question

所以我正在尝试编写一个反转给定字符串的方法，但问题是它必须是一个void方法而不是一个让这很困难的返回方法。我的代码对我来说似乎合乎逻辑，但它不起作用，所以我希望有人可以帮助我找出我出错的地方。

public class Reverser {

public String text, revText;

/**
 * @param args
 */
public static void main(String[] args) {
    Reverser greeting = new Reverser("Buildings");
    greeting.reverse();
    System.out.println(greeting.getText());

}

public Reverser(String _text){
    text = _text;
}

public void reverse(){
    int len = text.length();
    if(len >= 1){
        String last = text.substring(text.length() - 1, text.length());
        revText += last;
        text = text.substring(0, text.length() - 1);
        Reverser loop = new Reverser(text);     
        loop.reverse();         
    }
}

public String getText(){

    return revText; 
}

}

Answer 1

这是一个想法：

public class Reverser {

    private int idx;
    private String text, revText;

    public static void main(String[] args) {
        Reverser greeting = new Reverser("Buildings");
        greeting.reverse();
        System.out.println(greeting.getText());
    }

    public void reverse() {
        if (idx == text.length())
            return;
        revText = text.charAt(idx) + revText;
        idx++;
        reverse();
    }

    public Reverser(String _text) {
        idx = 0;
        text = _text;
        revText = "";
    }

    public String getText() {
        return revText; 
    }

}

与答案的根本区别在于，我使用索引属性来跟踪我在递归中的确切位置。这样，我就不必修改原始文本属性。

Answer 2

与奥斯卡·洛佩兹 (Oscar Lopez) 的回应略有不同的版本是

public class Sentence{
    private String sntce, rvrse;
    private int idx;

    public Sentence(String sentence){
        sntce = sentence;
        rvrse = "";
    }

    /**
        A method to reverse a string recursively. 
        @return void. 
    */
    void reverse(){
        if (idx  == sntce.length()){
            sntce = rvrse;
            return;
        }

        rvrse = sntce.charAt(idx) + rvrse;
        idx++;
        reverse();

    }
    /**
        To test reverse gives the appropriate value. 
        @return the value of sntce. 
    */
    public String getText(){
        return sntce;
    }
}

Answer 3

这是一个使用尽可能少的实例变量的版本。不幸的是，您需要至少一个实例变量来保存最终结果（result）。否则，状态将被传递到每个递归调用中。

（PS，这是家庭作业吗？）

public class RecursiveVoidStringReverser {

    public static void main(String[] args) {
        final RecursiveVoidStringReverser reverser = new RecursiveVoidStringReverser();
        reverser.reverse("Welcome to the jungle!");
        System.out.println("reverser.result = " + reverser.result());
    }

    private String result;

    public void reverse(String s) {
        if ("".equals(s)) {
            result = s;
        } else {
            reverse(s.toCharArray(), 0);
        }
    }

    private void reverse(char[] chars, int index) {
        if (index > chars.length / 2) {
            result = new String(chars);
        } else {
            char t = chars[index];
            chars[index] = chars[chars.length - index - 1];
            chars[chars.length - index - 1] = t;
            reverse(chars, index+1);
        }
    }

    public String result() {
        return result;
    }
}

Answer 4

鉴于字符串是不可变的，您无法在原位更改它。如果唯一的要求是没有返回值，并且可以简单地打印出最后的字符串（或将其放入类变量），那么这对于至少一个字符的任何字符串都可以正常工作：

public static void main(String args[])
{
    reverse("", "original string");
}

public static void reverse(String reversed, String original)
{
    if(original.length() <= 1)
    {
        System.out.println(original.charAt(0) + reversed);
        // (or set it into a shared variable)
        return;
    }

    reverse(original.charAt(0) + reversed, original.substring(1));
}

此解决方案的目的是简化程序，而不是内存效率。这会产生非常不愉快的内存占用，实际上为原始中的每个字符创建两个内存中的字符串。然而，它在逻辑上非常简单。

当然，如果您只是倾销到控制台，那么您可以使用与具有返回值的算法几乎相同的算法来实现相同的功能：

public static void reverse(String original)
{
    if(original.length() < 1) return;

    System.out.print(original.charAt(original.length() - 1));
    reverse(original.substring(0, original.length() - 1));
}

使用递归void方法反转字符串

4 个答案: