以下是一些Java代码以递归方式反转字符串。在Java中使用递归来逆转字符串
有人可以解释它是如何工作的吗？
public static String reverse(String str) {
if ((null == str) || (str.length() <= 1)) {
return str;
}
return reverse(str.substring(1)) + str.charAt(0);
}
我不理解这可能如何工作。
该函数将一个字符串的第一个字符 - 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"
通过调试器运行它。一切都会变得清晰。
“迄今为止，最好的答案”？那么为什么它得到0？为什么人们会一直说要看它在这么长的弦上运行？在什么情况下它终止于“null == str”？即使是新创建的String对象也不会这样做。毕竟空字符串对象的长度是多少？ – 2013-03-14 01:58:11
你需要记住，你将不会只有一个调用 - 你将有嵌套调用。因此，当“最高度嵌套”呼叫立即返回（当它发现只是“o”）时，下一级将需要str.charAt(0) - 其中str在那个点是“lo”。所以这将返回“ol”。
然后下水平将收到“OL”，为的str其值（这是“LLO”）执行str.charAt(0)，返回“OLL”下一级进行。
然后下水平将收到“OLL”从它的递归调用，对于str其值（这是“ELLO”）执行str.charAt(0)，返回“欧莱”下一级进行。
然后最终水平将收到“OLL”从它的递归调用，对于str其值（这是“你好”）执行str.charAt(0)，返回“2009东海生日贺”到原来的主叫方。
它可能是有意义的思考堆栈，当您去：
// 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"
我认为这是正确的简单解释，而不是接受的，因为递归调用将首先被评估，然后是“str.charAt（0）”。将最后一行分为两行“String ab = reverse（str.substring（1））; return ab + str.charAt（0）;” – Jayesh 2016-03-07 05:17:03
因为这是递归的每一步输出会是这样的：
的结果：
的总收益价值会给你递归调用的结果加上第一个字符
到从5的返回将是： “○”
从4所述的回报将是： “O” + “L”
从3所述的回报将是： “醇” + “升”
2的回报将是： “OLL” + “E”
1的回报将是： “欧莱” + “H”
这会给你 “2009东海生日贺” 的结果
取出字符串Hello并通过递归运行它。
所以第一次调用返回：
return reverse(ello) + H
二
return reverse(llo) + e
最终将返回olleH
的调用reverce（子（1））西港岛线之前进行添加charAt（0）。 由于调用是嵌套的，因此在添加ex-second字符（新的第一个字符，因为这是子字符串）之前调用子字符串的反向。
reverse（“ello”）+“H”=“ olleH“
--------^-------
reverse（”llo“）+”e“=”olle“
---------^- - ---
reverse（“lo”）+“l”=“oll”
--------^-----
reverse（“o”）+“l”=“ol “
---------^----
“O”= “o” 的
运行下面的代码 - 它打印：
步骤0：ELLO/H
第1步：LLO/E
第2步：LO /升
步骤3：O /升
步骤3返回：醇
步骤2返回：OLL
步骤1返回：奥莱
步骤0返回：2009东海生日贺
代码：
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;
}
}
运行以下，你会看到这是怎么回事：
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 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：\用户\管理员\桌面>的java管理器 萨米尔反向后：反向后 空值：：空 的Rahul反向后：反向后reemaS 单个字符luhaR
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中反转字符串的另一种解决方案。
使用.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;
}
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;
}
}
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));
}
}
在线样本;
public static String strrev(String str) {
return !str.equals("") ? strrev(str.substring(1)) + str.charAt(0) : str;
}
使用递归来反转字符串是一个坏程序员的明确标志。 – DwB 2012-03-15 16:34:38
这是作业，@DwB - 我认为这是递归的合理示范。 – adelphus 2012-03-15 16:37:31
@DwB它有一个作业标签，所以他们可能使用它来教授递归。它是理解递归如何工作的最简单方法之一 – jzworkman 2012-03-15 16:38:24