在Java中使用recursion来反转string
这是一些Java代码来recursion地反转string。
有人可以提供解释它是如何工作的？
public static String reverse(String str) { if ((null == str) || (str.length() <= 1)) { return str; } return reverse(str.substring(1)) + str.charAt(0); } 我不明白这可能会如何工作。
该函数采用String的第一个字符 – str.charAt(0) – 将其放在最后，然后调用自己 – reverse() – 其余部分 – str.substring(1) ，将这两个东西加在一起得到结果 – reverse(str.substring(1)) + str.charAt(0)
当传入的string是一个字符或更less，所以不会有剩余 – 当str.length() <= 1) – 它会停止recursion调用，只是返回传入的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"
你需要记住，你不会有一个电话 – 你会有嵌套的电话。 因此，当“最高度嵌套”调用立即返回（当它发现只是“o”）时，下一级将采取str.charAt(0) – 其中str是“lo”在那一点。 所以这将返回“ol”。
然后下一级会收到“ol”，执行str.charAt(0)得到str值（即“llo”），返回“oll”到下一级。
然后下一级将从recursion调用中接收“oll”，执行str.charAt(0)得到str值（即“ello”），返回“olle”到下一级。
然后最后一级从recursion调用中接收到“oll”，执行str.charAt(0)得到str值（即“hello”），返回“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"
通过debugging器运行它。 一切都会变得清晰。
因为这是recursion的，你在每一步的输出将是这样的：
- “你好”被input。 然后该方法调用自己“ello”，并返回结果+“H”
- “你好”被input。 该方法用“llo”调用自己，并返回结果+“e”
- “llo”被input。 该方法用“lo”调用自己，并返回结果+“l”
- input“lo”。 该方法用“o”调用自己，并返回结果+“l”
- input“o”。 该方法将打if条件并返回“o”
所以现在看结果：
总的返回值会给你recursion调用的结果加上第一个字符
从5返回将是：“o”
从4返回将是：“o”+“l”
3的返回将是：“ol”+“l”
2的返回将是：“oll”+“e”
从1返回将是：“olle”+“H”
这会给你“olleH”的结果
运行下面的代码 – 它打印：
第0步：ello / H
第1步：llo / e
第二步：升/升
第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; } }
采取string你好，并recursion运行。
所以第一个电话会返回：
return reverse(ello) + H
第二
return reverse(llo) + e
这将最终返回olleH
在添加charAt（0）之前，将执行对混响（substring（1））的调用。 因为调用是嵌套的，所以在添加ex-second字符（新的第一个字符，因为这是子string）之前，将调用子string的反转，
反向（“ello”）+“H”=“olleH”
——– ——- ^
反向（“llo”）+“e”=“olle”
——— ^ —–
反向（“lo”）+“l”=“oll”
——– ^ —–
反向（“o”）+“l”=“ol”
——— ^ —-
“o”=“o”
最好的解决scheme，我发现。
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：\用户\pipe理\桌面> javapipe理器相反后：reemaS单字符a后反向：后空值：空后反转后的Rahul：luhaR
运行以下，你会看到发生了什么事情：
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"); } }
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" }
}
另一种在Java中反转string的解决scheme。
使用.toCharArray（）函数将string转换为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; }
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)); } }
这是一个示例代码片段，这可能会帮助你。 为我工作。
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)); } }
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; } }
