Каков наилучший способ рекурсивного обращения строки в Java?

Question

Я сегодня возился с рекурсией. Часто методика программирования используется недостаточно.

Я решил рекурсивно перевернуть строку. Вот что я придумал:

//A method to reverse a string using recursion
    public String reverseString(String s){
        char c = s.charAt(s.length()-1);
        if(s.length() == 1) return Character.toString(c);   

        return c + reverseString(s.substring(0,s.length()-1));
    }

Мой вопрос: есть ли лучший способ в Java?

Answer 1

Уже есть около 20 ответов, но я просто добавлю свой рекурсивный алгоритм. Это может быть немного многословно, но это по крайней мере читабельно.

public static String reverseString(String str) {
   return reverseString("", str);
}

private static String reverseString(String result, String original) {
   if (original.length() == 0) {
      return result;
   } else {
      int length = original.length();
      String lastLetter = original.substring(length - 1, length);
      original = original.substring(0, length - 1);
      return reverseString(result + lastLetter, original);
   }
}

Код в основном рекурсивно берет конец строки и перемещает его вперед. Например, если строка, которую мы хотим изменить, - это «jam», то каждый раз, когда вызывается вспомогательный метод, строки result и original выглядят следующим образом:

// result:  original:
// ""       jam
// m        ja
// ma       j
// maj      ""

Answer 2

Если вы думаете, что меньше кода - это хорошо, тогда ....

static String reverse(String str){
    return str.length()>=2 ? str.charAt(str.length()-1) + reverse(str.substring(0,str.length()-1)) : str ;
}

Answer 3

public class StringUtility {

public static void main(String[] args) {
    StringUtility stringUtility = new StringUtility();

    String input = "santosh123";
    int middle = input.length() / 2;
    middle = middle - 1;
    System.out.println(stringUtility.stringReverse(input, middle));
}

public String stringReverse(String input, int middle) {

    if (middle == -1) {

        System.out.println("if");
        return input;

    } else {

        System.out.println("else");
        input = swapChar(input, middle);
        middle = middle - 1;
        return stringReverse(input, middle);

    }

}

private String swapChar(String input, int middle) {
    StringBuilder str = new StringBuilder(input);
    char begin = str.charAt(middle);
    int endIndex = input.length() - middle - 1;
    char end = str.charAt(endIndex);
    str.setCharAt(middle, end);
    str.setCharAt(endIndex, begin);
    System.out.println(str + "  " + middle + "  " + endIndex);
    return str.toString();
}

}

Answer 4

public String reverseString (String s) {

    if (s != null && s.length () > 0 ) {
        rev = rev + s.substring (s.length () - 1);
        reverseString (s.substring (0, s.length () - 1));
    }
    return rev;

}

Answer 5

public static String reverse(String s){

    int n = s.length()-1;

    if(n >=0)
    return  s.substring(s.length()-1)+ReverseString(s.substring(0,n--));
    else return "";
}

Answer 6

Вы можете попробовать с внешней переменной и добавить 1 на 1 все символы:

    public static String back="";

public static String reverseString(String str){


    if(str.length()==0){

        return back;

    }else {

        back+=str.charAt(str.length()-1);

        lees(str.substring(0,str.length()-1));


        return back;

    }

}

Answer 7

public static String rev(String name){
    if(name.length()>=1){
    System.out.print(name.charAt(name.length()-1)); 
    return rev(name.substring(0,name.length()-1));
    }
    else{
        return ""+name.substring(0);
    }
}

Answer 8

Это определенно то, как я бы пошел о рекурсивном обращении строки (хотя было бы неплохо расширить ее до случая пустой строки в вашем состоянии.) Я не думаю, что есть какой-то принципиально лучший способ.

РЕДАКТИРОВАТЬ: может быть более эффективно работать с массивом символов и передавать длину отсечки вниз по цепочке рекурсии, если вы понимаете мой дрейф, вместо создания подстрок. Тем не менее, это не стоит придираться, поскольку это не очень эффективный метод в первую очередь.

Answer 9

Попробуйте следующее:

public class reverse2
{
    public static void main(String name)
    {
    String revname=new StringBuffer(name).reverse().toString();
    System.out.println("original string " + name + " and the reverse of it is " + revname);
    }
}

Answer 10

В этом контексте это совершенно не нужно, но вы можете смоделировать рекурсию и избежать проблем с глубиной рекурсии, если создаете свой собственный стек.

Вы можете итеративно реализовать рекурсию, которая может быть необходима, когда у вас есть алгоритмы, которые по своей природе являются рекурсивными, но также должны запускать их для больших размеров задач.

String recIterReverse (String word){

    Stack <String> stack = new Stack <String> ();
    stack.push(word);
    String result = "";

    while (!stack.isEmpty()){
        String temp = stack.pop();
        result = temp.charAt(0) + result;

        if (temp.length() > 1){
        stack.push(temp.substring(1));
        }
    }

    return result;
}