it-swarm.com.de

Rückgängigmachen einer Zeichenfolge mit Rekursion in Java

Hier ist etwas Java-Code, um eine Zeichenfolge rekursiv umzukehren. 

Kann jemand erklären, wie es funktioniert?

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

Ich verstehe nicht, wie das funktionieren kann.

47
Bob Sanders

Die Funktion nimmt das erste Zeichen eines Strings - str.charAt(0) - am Ende und ruft sich selbst - reverse() - für den Rest - str.substring(1) auf. Diese beiden Dinge addieren, um das Ergebnis zu erhalten - reverse(str.substring(1)) + str.charAt(0) 

Wenn der übergebene String ein Zeichen oder weniger ist und somit kein Rest übrig ist - wenn str.length() <= 1) -, hört er auf, sich selbst rekursiv aufzurufen, und gibt nur den übergebenen String zurück.

So läuft es wie folgt:

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"
91
Dave Webb

Sie müssen sich daran erinnern, dass Sie nicht nur einen Anruf haben - Sie haben verschachtelte Anrufe. Wenn also der "am höchsten verschachtelte" Aufruf sofort zurückkehrt (wenn er nur "o" findet), wird für die nächsthöhere Ebene str.charAt(0) genommen, wobei str an diesem Punkt "lo" ist. Das wird also "ol" zurückgeben.

Dann erhält das next level "ol", führt str.charAt(0) für seinen Wert von str (was "llo" ist) aus und kehrt "oll" zum nächsten Level zurück.

Dann erhält das next level das "oll" von seinem rekursiven Aufruf, führt str.charAt(0) für seinen - Wert von str (was "Ello" ist) aus und kehrt "olle" zum nächsten Level zurück.

Dann erhält das final level das "oll" von seinem rekursiven Aufruf, führt str.charAt(0) für seinen - Wert von str (was "hallo" ist) aus und gibt "olleh" an den ursprünglichen Aufrufer zurück.

Es kann sinnvoll sein, an den Stack zu denken:

// 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" 
20
Jon Skeet

Führen Sie es durch einen Debugger aus. Alles wird klar werden.

3
Dave

Da dies rekursiv ist, würde Ihre Ausgabe bei jedem Schritt ungefähr so ​​aussehen:

  1. "Hallo" ist eingetragen. Die Methode ruft sich dann mit "Ello" auf und gibt das Ergebnis + "H" zurück.
  2. "Ello" wird eingegeben. Die Methode ruft sich mit "llo" auf und gibt das Ergebnis + "e" zurück.
  3. "llo" wird eingegeben. Die Methode ruft sich mit "lo" auf und gibt das Ergebnis + "l" zurück.
  4. "lo" wird eingegeben. Die Methode ruft sich mit "o" auf und gibt das Ergebnis + "l" zurück.
  5. "o" wird eingegeben. Die Methode trifft die if-Bedingung und gibt "o" zurück.

Nun zu den Ergebnissen:

Der Gesamtrückgabewert liefert Ihnen das Ergebnis des rekursiven Aufrufs plus das erste Zeichen

Die Rückkehr von 5 wird sein: "o"

Die Rückkehr von 4 wird sein: "o" + "l"

Die Rückkehr von 3 wird sein: "ol" + "l"

Die Rückkehr von 2 wird sein: "oll" + "e"

Die Rückkehr von 1 ist: "olle" + "H"

Dies gibt Ihnen das Ergebnis von "olleH"

2
jzworkman

Führen Sie den folgenden Code aus - es wird gedruckt:

Schritt 0: Ello/H
Schritt 1: Ilo/e
Schritt 2: lo/l
Schritt 3: o/l
Schritt 3 kehrt zurück: ol
Schritt 2 kehrt zurück: oll
Schritt 1 kehrt zurück: olle
Schritt 0 gibt zurück: olleH 

Code:

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

Inline-Probe;

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

führen Sie folgendes aus und Sie werden sehen, was los ist:

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

}
0
Tom

AFAIK, es gibt 2 Dinge in jeder Rekursionsfunktion:

  1. Es gibt immer eine Stoppbedingung welche ist:

    if ((null == str) || (str.length () <= 1)) {return str; }

  2. Rekursion benutze den Stack Speicher, der den [~ # ~] lifo [~ # ~] Mechanismus benutzt, weshalb die Rückgängigmachung geschieht.

0
Chulo

Beste Lösung was ich gefunden habe.

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

Ausgabe: C:\Users\admin\Desktop> Java Manager Gleiches nach reverse: reemaS Einzelzeichen a nach reverse: a Nullwert nach reverse: null Rahul after reverse: luhaR

0
Vicky K
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));
   }
}
0
Chris Zog

Weitere Lösungen zum Umkehren eines Strings in Java.

Konvertieren Sie Ihren String mit der .toCharArray () - Funktion in ein Char-Array.

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;

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

}

0
Venkata Buchi
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));
} }

Hier ist ein Beispiel-Code-Snippet, der Ihnen helfen kann. Arbeitete für mich.

0
Kaustubh

Nehmen Sie den String Hello und führen Sie ihn rekursiv durch. 

Der erste Anruf wird zurückgegeben:

return reverse(Ello) + H

Zweite

return reverse(llo) + e

Welches wird schließlich olleH zurückgeben

0
len

Der Aufruf der Umkehrung (Teilzeichenfolge (1)) wird vor dem Hinzufügen des Zeichens (0) ..__ durchgeführt. Da der Aufruf verschachtelt ist, wird die Umkehrung des Teilzeichens aufgerufen, bevor das Ex-Sekundenzeichen (das neue Zeichen) eingefügt wird erstes Zeichen, da dies der Teilstring ist)

reverse ("Ello") + "H" = "olleH"
-------- ^ -------
reverse ("llo") + "e" = "olle"
--------- ^ -----
reverse ("lo") + "l" = "oll"
-------- ^ -----
reverse ("o") + "l" = "ol"
--------- ^ ----
"o" = "o" 

0
PATRY Guillaume