在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的,你在每一步的输出将是这样的:

  1. “你好”被input。 然后该方法调用自己“ello”,并返回结果+“H”
  2. “你好”被input。 该方法用“llo”调用自己,并返回结果+“e”
  3. “llo”被input。 该方法用“lo”调用自己,并返回结果+“l”
  4. input“lo”。 该方法用“o”调用自己,并返回结果+“l”
  5. 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; } }