在Java中使用遞歸反轉字符串

Question

這是一些遞歸反轉字符串的Java代碼。

有人可以解釋它是如何工作的嗎？

public static String reverse(String str) {
    if ((null == str) || (str.length() <= 1)) {
        return str;
    }
    return reverse(str.substring(1)) + str.charAt(0);
}

我不明白這是如何工作的。

Answer 1

該函數接受String的第一個字符 - str.charAt(0) - 將它放在最后然后調用自身 - reverse() - 在余數 - str.substring(1) ，將這兩個東西加在一起得到它result - 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"

Answer 2

你需要記住，你不會只有一個電話 - 你將有嵌套的電話。 因此，當“最高度嵌套”的調用立即返回時（當它找到“o”時），下一級別將采用str.charAt(0) - 其中str在該點為“lo”。 這將返回“ol”。

然后下一級將接收“ol”，執行str.charAt(0)獲取其 str值（即“llo”），將“oll”返回到下一級別。

然后下一級將從其遞歸調用接收“oll”，執行str.charAt(0)獲取其 str值（即“ello”），將“olle”返回到下一級別。

然后最終級別將從其遞歸調用接收“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" 

Answer 3

通過調試器運行它。 一切都會變得清晰。

Answer 4

內聯樣本;

public static String strrev(String str) {
    return !str.equals("") ? strrev(str.substring(1)) + str.charAt(0) : str;
}

Answer 5

因為這是遞歸的，所以每一步的輸出都是這樣的：

1. 輸入“Hello”。 然后該方法用“ello”調用自己並返回結果+“H”
2. “ello”進入了。 該方法使用“llo”調用自身並返回結果+“e”
3. 輸入“llo”。 該方法使用“lo”調用自身並返回結果+“l”
4. 輸入“lo”。 該方法使用“o”調用自身並返回結果+“l”
5. 輸入“o”。 該方法將命中if條件並返回“o”

所以現在結果如下：

總返回值將為您提供遞歸調用的結果以及第一個char

從5回來將是：“o”

從4返回將是：“o”+“l”

從3返回將是：“ol”+“l”

從2返回將是：“oll”+“e”

從1返回將是：“olle”+“H”

這會給你“olleH”的結果

Answer 6

運行下面的代碼 - 它打印：

第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;
    }
}

Answer 7

我找到的最佳解決方案。

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>反向后的java Manager Sameer：反轉后的reemaS單字符a：反向后的空值：反轉后的空Rahul：luhaR

Answer 8

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"
}

}

Answer 9

另一種在Java中反轉String的解決方案。

使用.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;

    }

Answer 10

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));
} }

這是一個示例代碼段，這可能對您有所幫助。 為我工作。

Answer 11

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));
   }
}

Answer 12

AFAIK，每個遞歸函數有兩件事：

1. 始終存在停止條件 ：

   if（（null == str）||（str.length（）<= 1））{return str; }

2. 遞歸使用堆棧內存使用LIFO機制，這就是恢復發生的原因。

Answer 13

取字符串Hello並遞歸運行。

所以第一個電話將返回：

return reverse(ello) + H

第二

return reverse(llo) + e

哪個最終會回歸olleH

Answer 14

在添加charAt（0）之前，將執行對reverce（substring（1））的調用。 由於調用是嵌套的，因此在添加ex-second字符之前將調用子字符串的反向（因為這是子字符串，所以是新的第一個字符）

反向（“ello”）+“H”=“olleH”
-------- ------- ^
反向（“llo”）+“e”=“olle”
--------- ^ -----
反向（“lo”）+“l”=“oll”
-------- ^ -----
反向（“o”）+“l”=“ol”
--------- ^ ----
“o”=“o”

Answer 15

運行以下內容，您將看到發生了什么：

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");
    }

}

Answer 16

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;
    }
}

Answer 17

試試這個：

public static String reverse(String str) {
   return (str == null || str.length()==0) ? str : reverseString2(str.substring(1))+str.charAt(0);
}