web-dev-qa-db-fra.com

Inversion d'une chaîne avec récursivité en Java

Voici du code Java pour inverser une chaîne de manière récursive. 

Quelqu'un pourrait-il expliquer comment cela fonctionne?

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

Je ne comprends pas comment cela peut éventuellement fonctionner.

javastringrecursionreverse
47
Bob Sanders

La fonction prend le premier caractère d'une chaîne - str.charAt(0) - la met à la fin puis s'appelle - reverse() - sur le reste - str.substring(1), en additionnant ces deux éléments pour obtenir son résultat - reverse(str.substring(1)) + str.charAt(0) 

Lorsque la valeur passée dans String correspond à un caractère ou moins, il ne restera donc aucun reste - lorsque str.length() <= 1) - il cessera de s’appeler de manière récursive et ne renverra que la chaîne transmise.

Donc, il fonctionne comme suit:

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

Vous devez vous rappeler que vous n’aurez pas un seul appel one - vous aurez des appels nested. Ainsi, lorsque l'appel "le plus imbriqué" revient immédiatement (lorsqu'il trouve juste "o"), le prochain niveau supérieur prendra str.charAt(0) - où str est "lo" à ce stade. Donc, ça va revenir "ol".

Ensuite, le niveau next recevra "ol", exécutera str.charAt(0) pour sa valeur de str (qui est "llo"), renvoyant "oll" au niveau suivant.

Ensuite, le niveau next recevra le "oll" de son appel récursif, exécutez str.charAt(0) pour sa valeur de str (qui est "Ello"), renvoyant "olle" au niveau suivant.

Ensuite, le niveau final recevra le "oll" de son appel récursif, exécutez str.charAt(0) pour sa valeur de str (qui est "hello"), renvoyant "olleh" à l'appelant d'origine.

Il peut être logique de penser à la pile au fur et à mesure:

// 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

Exécutez-le à travers un débogueur. Tout deviendra clair.

3
Dave

Parce que ceci est récursif, votre sortie à chaque étape ressemblerait à ceci:

  1. "Bonjour" est entré. La méthode s’appelle alors avec "Ello" et retournera le résultat + "H"
  2. "Ello" est entré. La méthode s’appelle avec "llo" et retournera le résultat + "e"
  3. "llo" est entré. La méthode s’appelle avec "lo" et retournera le résultat + "l"
  4. "lo" est entré. La méthode s’appelle avec "o" et retournera le résultat + "l"
  5. "o" est entré. La méthode remplira la condition if et retournera "o"

Passons maintenant aux résultats:

La valeur de retour total vous donnera le résultat de l'appel récursif plus le premier caractère

Pour le retour de 5 sera: "o"

Le retour de 4 sera: "o" + "l"

Le retour de 3 sera: "ol" + "l"

Le retour de 2 sera: "oll" + "e"

Le retour de 1 sera: "olle" + "H"

Cela vous donnera le résultat de "olleH"

2
jzworkman

Exécutez le code ci-dessous - il affiche:

Étape 0: Ello/H
Étape 1: llo/e
Étape 2: bas/l
Étape 3: o/l
Étape 3 retourne: ol
Étape 2 retourne: oll
Étape 1 retourne: olle
L'étape 0 renvoie: 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

Échantillon en ligne;

public static String strrev(String str) {
    return !str.equals("") ? strrev(str.substring(1)) + str.charAt(0) : str;
}
2
Fatih Mert Doğancan

lancez ce qui suit et vous verrez ce qui se passe:

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

Meilleure solution ce que j'ai trouvé.

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

Sortie: C:\Utilisateurs\admin\Bureau> Gestionnaire Java Identifiant après inversion: reemaS Caractère unique a après inversion: a Valeur nulle après inversion: null Rahul après inversion: 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

Une autre solution pour inverser une chaîne en Java.

Convertissez votre chaîne en tableau de caractères en utilisant la fonction .toCharArray ().

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

Voici un exemple d'extrait de code, cela pourrait vous aider. Travaillé pour moi.

0
Kaustubh

Prenez la chaîne Hello et parcourez-la récursivement. 

Donc, le premier appel retournera:

return reverse(Ello) + H

Seconde

return reverse(llo) + e

Ce qui finira par retourner olleH

0
len

L’appel à la reverce (sous-chaîne (1)) sera effectué avant l’ajout du caractère charAt (0) . Puisque l’appel est imbriqué, l’inverse sur la sous-chaîne sera alors appelé avant l’ajout du caractère ex-seconde (le nouveau premier caractère puisqu'il s'agit de la sous-chaîne)

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

0
PATRY Guillaume