在J中使用递归反转字符串

这是一些Java代码,以递归方式反转字符串。

有人可以解释一下它是如何工作的吗?

public static String reverse(String str) {
    if ((null == str) || (str.length() <= 1)) {
        return str;
    }
    return reverse(str.substring(1)) + str.charAt(0);
}

我不明白这可能如何工作。

Bob Sanders asked 2020-02-19T07:13:29Z
17个解决方案
93 votes

该函数采用字符串的第一个字符-str.length() <= 1)-将其放在末尾,然后调用自身-reverse()-其余部分-str.substring(1),将这两件事加在一起即可得到结果-reverse(str.substring(1)) + str.charAt(0)

当传入的String是一个字符或更少个字符时,因此将没有剩余-str.length() <= 1)-它停止递归调用自身,而仅返回传入的String。

因此运行如下:

reverse("Hello")
(reverse("ello")) + "H"
((reverse("llo")) + "e") + "H"
(((reverse("lo")) + "l") + "e") + "H"
((((reverse("o")) + "l") + "l") + "e") + "H"
(((("o") + "l") + "l") + "e") + "H"
"olleH"
Dave Webb answered 2020-02-19T07:13:46Z
20 votes

您需要记住,您不会只有一个电话-您将有嵌套电话。 因此,当“高度嵌套”的调用立即返回时(当它找到“ o”时),下一个升级将花费str.charAt(0)-此处str在该位置为“ lo”。 这样就返回“ ol”。

然后下一级将接收“ ol”,对其值str(即“ llo”)执行str.charAt(0)(将“ oll”返回到下一级)。

然后,下一个级别将从其递归调用中接收“费用”,对str969(即“ ello”)的值执行str.charAt(0)(将“ olle”返回到下一个级别)。

然后,最终级别将从其递归调用中接收“费用”,对其值str969(即“ hello”)执行str.charAt(0)(将“ olleh”返回给原始调用者)。

边走边考虑堆栈可能很有意义:

// Most deeply nested call first...
reverse("o") -> returns "o"
reverse("lo") -> adds 'l', returns "ol" 
reverse("llo") -> adds 'l', returns "oll" 
reverse("ello") -> adds 'e', returns "olle" 
reverse("hello") -> adds 'h', returns "olleh" 
Jon Skeet answered 2020-02-19T07:14:25Z
4 votes

通过调试器运行它。一切都将变得清晰起来。

Dave answered 2020-02-19T07:14:47Z
2 votes

因为这是递归的,所以每一步的输出都是这样的:

  1. 输入“ Hello”。 然后该方法用“ ello”调用自身,并将返回结果+“ H”
  2. 输入“ ello”。 该方法使用“ llo”调用自身,并将返回结果+“ e”
  3. 输入“ llo”。 该方法使用“ lo”调用自身,并将返回结果+“ l”
  4. 输入“ lo”。 该方法使用“ o”调用自身,并将返回结果+“ l”
  5. 输入“ o”。 该方法将满足if条件并返回“ o”

现在来看结果:

总的返回值将为您提供递归调用的结果加上第一个字符

从5返回的值将为:“ o”

从4的返回将是:“ o” +“ l”

3的返回值将是:“ ol” +“ l”

2的返回值是:“ oll” +“ e”

从1的返回将是:“ olle” +“ H”

这将为您提供“ olleH”的结果

jzworkman answered 2020-02-19T07:16:05Z
2 votes

运行以下代码-打印:

步骤0:ello / H
步骤1:LLO / E
步骤2:lo / l
步骤3:o / l
步骤3返回:ol
步骤2返回:oll
步骤1返回:olle
步骤0返回:olleH

码:

public class Test {

    private static int i = 0;

    public static void main(String args[]) {
        reverse("Hello");
    }

    public static String reverse(String str) {
        int localI = i++;
        if ((null == str) || (str.length()  <= 1)) {
            return str;
        }
        System.out.println("Step " + localI + ": " + str.substring(1) + " / " + str.charAt(0));
        String reversed = reverse(str.substring(1)) + str.charAt(0);

        System.out.println("Step " + localI + " returns: " + reversed);
        return reversed;
    }
}
assylias answered 2020-02-19T07:17:04Z
2 votes

在线样本;

public static String strrev(String str) {
    return !str.equals("") ? strrev(str.substring(1)) + str.charAt(0) : str;
}
Fatih Mert Doğancan answered 2020-02-19T07:17:23Z
0 votes

接受字符串Hello,然后递归运行它。

因此,第一个电话将返回:

return reverse(ello) + H

第二

return reverse(llo) + e

最终将返回olleH

len answered 2020-02-19T07:17:57Z
0 votes

对reverce(substring(1))的调用将在添加charAt(0)之前执行。由于调用是嵌套的,因此在添加第二个字符(因为这是子字符串的新第一个字符)之前,将调用子字符串上的反向字符

反向(“ ello”)+“ H” =“ olleH”
-------- ^ -------
反向(“ llo”)+“ e” =“ olle”
--------- ^ -----
反向(“ lo”)+“ l” =“ oll”
-------- ^ -----
反向(“ o”)+“ l” =“ ol”
--------- ^ ----
“ o” =“ o”

PATRY Guillaume answered 2020-02-19T07:18:56Z
0 votes

我发现的最佳解决方案。

public class Manager
{
    public static void main(String[] args)
    {
        System.out.println("Sameer after reverse : " 
                         + Manager.reverse("Sameer"));
        System.out.println("Single Character a after reverse : " 
                         + Manager.reverse("a"));
        System.out.println("Null Value after reverse : "
                         + Manager.reverse(null));
        System.out.println("Rahul after reverse : "
                         + Manager.reverse("Rahul"));
    }

    public static String reverse(String args)
    {
        if(args == null || args.length() < 1 
                                || args.length() == 1)
        {
            return args;
        }
        else
        {
                return "" + 
                               args.charAt(args.length()-1) + 
                               reverse(args.substring(0, args.length()-1));                                  
        }
    }
}

输出:C:\ Users \ admin \ Desktop> java管理器反向后相同:reemaS反向后的单个字符a:反向后的Null值:null反向后的Rahul:luhaR

Vicky K answered 2020-02-19T07:19:20Z
0 votes

运行以下命令,您将看到发生了什么事:

public class RS {

    public static String reverse(String str) {
        System.out.println("--- reverse --- " + str);
        if ((null == str) || (str.length() <= 1)) {
            return str;
        }
        return add(reverse(str.substring(1)), charAt(str));
    }

    public static char charAt(String s) {
        System.out.println("--- charAt --- " + s);
        return s.charAt(0);
    }

    public static String add(String s, char c) {
        System.out.println("--- add --- " + s + " - " + c);
        return s + c;
    }

    public static void main(String[] args) {
        System.out.println("start");
        System.out.println("result: " + reverse("hello"));
        System.out.println("end");
    }

}
Tom answered 2020-02-19T07:19:41Z
0 votes
public class ReverseString{

private static  String reverse(String text, String reverseStr){
    if(text == null || text.length() == 0){
        return reverseStr;
    }
    return reverse(text.substring(1), text.charAt(0)+reverseStr);
}
public static void main(String [] args){
    System.out.println(reverse("hello", "")); //output is "olleh"
}

}

Venkata Buchi answered 2020-02-19T07:20:01Z
0 votes

Java中反转字符串的另一种解决方案。

使用.toCharArray()函数将字符串转换为char数组。

public static char[] reverse(char in[], int inLength, char out[],
            int tractOut) {

        if (inLength >= 0) {
            out[tractOut] = in[inLength];
            reverse(in, inLength - 1, out, tractOut + 1);
        }

        return null;

    }
Rakesh Chaudhari answered 2020-02-19T07:20:25Z
0 votes
class Test {
   public static void main (String[] args){
      String input = "hello";
      System.out.println(reverse(input));
    }

    private static String reverse(String input) {
        if(input.equals("") || input == null) {
        return "";
    }
    return input.substring(input.length()-1) + reverse(input.substring(0, input.length()-1));
} }

这是一个示例代码片段,可能会对您有所帮助。 为我工作。

Kaustubh answered 2020-02-19T07:20:45Z
0 votes
import java.util.*;

public class StringReverser
{
   static Scanner keyboard = new Scanner(System.in);

   public static String getReverser(String in, int i)
   {
      if (i < 0)
         return "";
      else
         return in.charAt(i) + getReverser(in, i-1);
   }

   public static void main (String[] args)
   {
      int index = 0;

      System.out.println("Enter a String");
      String input = keyboard.nextLine();


      System.out.println(getReverser(input, input.length()-1));
   }
}
Chris Zog answered 2020-02-19T07:21:00Z
0 votes

AFAIK,每个递归函数中都有两件事:

  1. 总会有一个停止条件:

    如果((null == str)||(str.length()<= 1)){           返回str;       }

  2. 递归使用使用LIFO机制的堆栈存储器,这就是发生还原的原因。

Chulo answered 2020-02-19T07:21:33Z
-1 votes
import java.util.Scanner;

public class recursion{
    public static void main (String []args){

    Scanner scan = new Scanner(System.in);
    System.out.print("Input: ");
    String input = scan.nextLine();

    System.out.print("Reversed: ");
    System.out.println(reverseStringVariable(input));

    }public static String reverseStringVariable(String s) {
        String reverseStringVariable = "";

        for (int i = s.length() - 1; i != -1; i--) {
            reverseStringVariable += s.charAt(i);

        }

        return reverseStringVariable;
    }
}
mymy answered 2020-02-19T07:21:49Z
-1 votes

尝试这个:

public static String reverse(String str) {
   return (str == null || str.length()==0) ? str : reverseString2(str.substring(1))+str.charAt(0);
}
vikash answered 2020-02-19T07:22:09Z
translate from https://stackoverflow.com:/questions/9723912/reversing-a-string-with-recursion-in-java