java recursion_在Java中使用recursion来反转string

该函数采用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; } }