这是一些递归反转字符串的Java代码。
有人可以解释它是如何工作的吗？
public static String reverse(String str) {
if ((null == str) || (str.length() <= 1)) {
return str;
}
return reverse(str.substring(1)) + str.charAt(0);
}
我不明白这是如何起作用的。
答案 0 :(得分：93)
该函数接受字符串的第一个字符 - str.charAt(0) - 将其放在最后，然后调用自身 - reverse() - 在余数 - str.substring(1)上，将这两个内容添加到一起得到它的结果 - reverse(str.substring(1)) + str.charAt(0)
当传入的String是一个或更少的字符，因此没有剩余的余数 - 当str.length() <= 1)时 - 它会停止以递归方式调用自身，只返回传入的字符串。
所以它运行如下：
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"
答案 1 :(得分：20)
您需要记住，您不会只有一个电话 - 您将拥有嵌套电话。因此，当“最高度嵌套”的调用立即返回时（当它只找到“o”时），下一级别将采用str.charAt(0) - 此时str为“lo”。所以这将返回“ol”。
然后 next 级别将收到“ol”，执行str.charAt(0) 其值str（即“llo”），让“oll”回到下一个级别。
然后 next 级别将从其递归调用中接收“oll”，为{em>其值str.charAt(0)执行str（这是“ello”），让“olle”更上一层楼。
然后 final 级别将从其递归调用中接收“oll”，为{em>其值str.charAt(0)执行str（这是“你好”），将“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"
答案 2 :(得分：3)
通过调试器运行它。一切都会变得清晰。
答案 3 :(得分：2)
因为这是递归的，所以每一步的输出都是这样的：
现在结果如下：
总返回值将为您提供递归调用的结果以及第一个char
从5返回将是：“o”
4的回报将是：“o”+“l”
3的回报将是：“ol”+“l”
从2返回将是：“oll”+“e”
1的回报将是：“olle”+“H”
这将为您提供“olleH”的结果
答案 4 :(得分：2)
内联样本;
public static String strrev(String str) {
return !str.equals("") ? strrev(str.substring(1)) + str.charAt(0) : str;
}
答案 5 :(得分：2)
运行下面的代码 - 它打印：
步骤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;
}
}
答案 6 :(得分：0)
我找到的最佳解决方案。
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＆gt; java Manager 反转后的萨梅尔：reemaS 反转后的单个字符a：a 反向后的空值：null 反转后的拉胡尔：luhaR
答案 7 :(得分：0)
AFAIK，每个递归函数中都有两件事：
总是有一个停止条件：
if（（null == str）||（str.length（）<= 1））{ return str; }
递归使用 stack 内存，该内存使用 LIFO 机制，这就是还原发生的原因。
答案 8 :(得分：0)
Class Choices 1 == 4,5,6
Class Choices 1 == 5,6,4
Class Choices 1 == 6,5,4
...
答案 9 :(得分：0)
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));
} }
以下是一个示例代码段，这可能会对您有所帮助。为我工作。
答案 10 :(得分：0)
在Java中反转String的另一种解决方案。
使用.toCharArray（）函数将字符串转换为char数组。
.sort()答案 11 :(得分：0)
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"
}
}
答案 12 :(得分：0)
运行以下内容，您将看到发生了什么：
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");
}
}
答案 13 :(得分：0)
在添加charAt（0）之前，将执行对reverce（substring（1））的调用。 由于调用是嵌套的，因此在添加ex-second字符之前将调用子字符串的反向（因为这是子字符串，所以是新的第一个字符）
反向（“ello”）+“H”=“olleH”
-------- ------- ^
反向（“llo”）+“e”=“olle”
--------- ^ -----
反向（“lo”）+“l”=“oll”
-------- ^ -----
反向（“o”）+“l”=“ol”
--------- ^ ----
“o”=“o”
答案 14 :(得分：0)
取字符串Hello并递归运行。
所以第一个电话将返回：
return reverse(ello) + H
第二
return reverse(llo) + e
最终将返回olleH
答案 15 :(得分：-1)
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;
}
}
答案 16 :(得分：-1)
尝试一下：
public static String reverse(String str) {
return (str == null || str.length()==0) ? str : reverseString2(str.substring(1))+str.charAt(0);
}