Sonntag, Juni 7, 2020

Java-Array-Rekursion

Zweck dieser Aufgabe ist, zu lernen, rekursive Methoden. Für dieses spezielle problem, ich muss zum drucken der Werte von list eine pro Zeile. Das Skelett der Methode, die ich erledigen müssen, können nicht geändert werden, und lautet wie folgt:

public void list (String[] list) {

}

Die Anweisungen sagen, dass helper-Methoden, die dies erleichtern können, zu schreiben. Hier ist, was ich für mein Helfer-Methode:

public void print(String[] list, int index) {    
      if (index < list.length) {
          System.out.println(list[index]);
          print(list, index+1);
      }
}  

Ich würde nur gerne die print-Methode durch die Liste Methode für die Prüfung. Ich kenne die Einstufung erfolgt über ein Skript, also nochmal ich kann nicht ändern Sie den Rückgabetyp und Parameter des in der Liste Methode. Bitte entschuldigen Sie meine Formatierung Fehler, und danke Ihnen im Voraus für Ihre Hilfe!

  • In der Regel, wenn Sie sehen, unsinnige Sachen wie, dass es nur ein Anfänger macht eine code-Formatierung Fehler. Klicken Sie auf Bearbeiten, und Sie können sehen, wo Sie falsch gelaufen ist und zu beheben. Ich habe dies bereits getan. Normalerweise ist es ziemlich offensichtlich, wo der Fehler ist und es hilft allen, wenn Sie es zu beheben.
  • Klasse gehen, achten Sie, das Buch zu Lesen, Fragen stellen, versuchen Sie, die Zuordnung, die kommen dann hier mit, was du hast.
  • das problem ist, dass die Menschen bereits gab den code an den Mann 😀 und jetzt wird er nicht gehen, um die nächste Klasse, nicht das Buch gelesen, weder die Frage, noch versuchen Sie, die Aufgabe 😀
  • Du hast Recht, und das ist das problem mit Menschen, die begierig, eine Antwort zu geben, nur um den Ruf auf der Website.
  • meta.stackexchange.com/questions/10811
InformationsquelleAutor Dan | 2011-02-25

7 Kommentare

  1. 2

    Wenn ich das machen würde ich eine helper-Methode mit dem Namen print() oder etwas ähnliches.

    In Bezug auf das denken über die Logik des Programms, darüber nachzudenken, was Sie hätte tun müssen:

    Haben eine helper-Methode print() dass:

    • Druckt das aktuelle Element in der Liste in einer neuen Zeile
    • Es ruft dann eine Funktion zum anzeigen der nächsten und der nachfolgenden Einträge in der Liste, die jeweils auf neuen Linien

    Was denken Sie, dass die zweite Funktion könnte das sein? Hinweis: Es ist rekursiv…

    • Ein anderer Hinweis für Dan: Fühlen Sie sich frei, um einen Kommentar auf unsere Antworten, so dass wir eingreifen können, in einen dialog hier, um zu versuchen, Ihnen zu helfen. Wir wollen nicht, um Ihnen die Antworten auf Ihre Hausaufgaben, aber bereit sind, Ihnen zu helfen, solange Sie sich bemühen, zu erhöhen, Ihr Verständnis und ein dialog.
  2. 1

    Ich werde nicht geben Ihnen direkte Antwort, da Sie nicht etwas daraus lernen. Sie können erstellen Sie die variable zum speichern der aktuellen Tiefe. Erstellen Sie getter-und setter-helper-Methoden zu erhöhen, die Tiefe der Rekursion. Ihre Methode in der Liste, wird der Anruf selbst, mit den gleichen array, aber nur, nachdem Sie überprüfen, dass die Tiefe nicht größer als die Größe des Arrays. Vergessen Sie nicht, erhöhen Sie die Tiefe der Rekursion bei jedem Anruf.

  3. 0

    Denken Sie an eine rekursive Lösung wie diese: gegeben ein paar Dinge (wie eine Liste), etwas mit eines dieser Dinge (wie das erste element der Liste), dann übergeben Sie den rest der Dinge, die zu der gleichen Lösung verarbeitet eines der Dinge, die

    Hinweis: Sie müssen darüber nachdenken, was Ihre Lösung ist in dem Fall, wenn es nichts gegeben.

    Tipp 2: Anstelle von „häckseln“ das array wird jedes mal, wenn Sie recurse, nur beachten Sie Ihren Platz im array.

  4. 0

    Wenn Ihr Rekursion, kann es manchmal hilfreich sein, zu schreiben, wie würden Sie die gleiche Aufgabe mit Hilfe einer Schleife:

    public void list(String[] list) {
        for(int index = 0; index < list.length; index++) {
            System.out.println(list[index]);
        }
    } 

    Nun, sagen wir, wir wollten um näher an eine rekursive Lösung. Der erste Schritt könnte sein, um loszuwerden, den inneren Teil der for Schleife:

    public void list(String[] list) {
        for(int index = 0; index < list.length; index++) {
            list(list, index);
        }
    }
    
    public void list(String[] list, int index) {
        System.out.println(list[index]);
    }

    Okay, jetzt sind wir wirklich in der Nähe der rekursiven Lösung. Wir müssen nur die letzten beiden Aufgaben, die Schleife ist Behandlung, erhöht index und prüfen, ob index < list.length. Diese sehen wie Sie sein könnten, große Kandidaten für eine Reduzierung der Schritt-und ein base-case.

  5. 0

    Let ‚ s start von Anfang an:

    Wahrscheinlich wissen Sie bereits, dass eine rekursive Funktion ist eine, die sich selbst aufruft. Jedes mal, wenn eine Funktion ausgeführt wird, ruft es sich selbst, sind Sie gehen, um am Ende in einer Endlosschleife. Daher ist es wichtig, immer sicherzustellen, dass Ihre Funktion weiß, Wann zu stoppen ruft sich selbst als gut.

    Wie können wir dies tun? Der Körper der Funktion ist nicht zu ändern, zwischen anrufen, da Sie zur Kompilierzeit festgelegt ist. Wird sich was ändern, jedoch ist die Eingabe für die Funktion. Wann immer Sie schreiben Sie eine rekursive Funktion, die Sie brauchen, um Logik, die zu vermeiden wird die rekursive aufrufen, wenn eine bestimmte Bedingung erfüllt ist.

    In deinem Beispiel die Eingabe für die Funktion ist ein array von Strings. Ein Weg, zu wissen, Wann man aufhören, den rekursiven Aufruf könnte sein, passieren eine kleinere array an die Funktion jedes mal, und stoppen Sie, wenn Sie ein leeres array. Dies würde besser funktionieren, in einer Sprache wie C, wo arrays ausgesetzt sind als Zeiger, aber in Java wäre es ineffizient, als würden Sie zum erstellen eines neuen array jedes mal.

    Schönere Lösung wäre die Aufrechterhaltung eines index, der auf Ihre aktuelle position in der Liste (dies ist, warum Sie benötigen eine Hilfsfunktion, die zu fügen Sie die zusätzlichen parameter). Bei jedem Anruf, können Sie drucken Sie einfach den String an den aktuellen index und das Inkrement des index. Wenn der index nicht mehr in dem array, fertig!

    Wenn Sie wirklich wollen, um ein gutes Verständnis von Rekursion, empfehle ich das erlernen einer funktionalen Sprache wie Lisp, Haskell oder ML. Funktionale Sprachen vermeiden mutable state (ändern der Werte von Variablen), und als solche sind Sie nicht mit Dingen wie for-Schleifen (wegen der Notwendigkeit, zu aktualisieren, einen loop-Zähler bei jeder iteration). So implementieren Sie Schleifen mit Rekursion statt! Zum Beispiel, in Java haben wir vielleicht:

    for (int i = 0; i < 10; i++) {
      System.out.println("Loop index: " + i);
    }

    in der Erwägung, dass in OCaml würden wir Folgendes schreiben:

    let times = 10 in
    let rec loop count =
      if count = times then
        printf "Loop index: %d" count ;
        loop (count + 1)
    ;;

    Der wichtige Unterschied hier ist, dass, anstatt ändern Sie den Wert von count (eigentlich nicht möglich, da die oben OCaml-code), passieren wir einen neuen Wert in das loop – Funktion jedes mal.

  6. 0

    Ich denke, das ist nicht die sehr guten Weg, auch wenn es hilfreich sein wird.

    static void traverse(int []x)
    {
        if(x.length == 0)
            return;
    
        traverse( Arrays.copyOf(x,x.length- 1));
    
        System.out.println(x[x.length-1]);
    
    }

Kostenlose Online-Tests