H
Wohin "returned" er denn?returnt er die 8 aber was macht er danach?
kannst du das nochmal schritt für schritt erklären? habe es fast verstanden.Es wird "8 " zurückgegeben und Du landest dort, wo zuvor die Methode aufgerufen wurde, d. h. im Knoten "5" in der Zeile s=s+left.toString() und zwar, nachdem left.toString() eben "8 " zurückgeliefert hat. Dann geht es weiter: s=s + "8 " wird zu s=""+"8 "="8 " ausgewertet.
Anschließend wir s = s + element + " " zu s = "8 " + "5" + " " = "8 5 " ausgewertet. Dann wird geschaut, ob ein rechter Knoten existiert. Da dies der Fall ist, wird jetzt s=s + right.toString() ausgeführt, d. h. zuerst right.toString() (-> liefert "12 ") und anschließend s = s + "12 ", also s="8 5 12 ". Das wird dann zurückgegeben.
Jetzt bist Du dort, wo die toString-Methode für Knoten 5 aufgerufen wurde, also im Knoten 19 in der Zeile s=s+left.toString(). Das left.toString() hat "8 5 12 " zurückgegeben, somit wird s = s + left.toString() zu s = "" + "8 5 12 " = "8 5 12 " ausgewertet.
Es folgt s = s + element + " ", also s = "8 5 12 " + "19" + " " = "8 5 12 19 ".
Jetzt wird wieder geschaut, ob ein rechter Knoten existiert. Da dies der Fall ist, wird jetzt s = s + right.toString() ausgeführt, zuerst wieder right.toString().
Usw.
Nachtrag: probier das Spiel mal gedanklich weiter zu spielen, wenn Du dem Knoten 199 noch einen linken Knoten hinzufügst.
aber der return kommt nach s = s + element ? man geht ja sequentiel vor ?Die Anweisung s = s + left.toString() kannst Du Dir so vorstellen:
Zuerst wird left.toString() ausgeführt, das liefert dann die "8 " zurück und anschließend wird die "8 " an die Zeichenkette s angehängt.Code:String tmp = left.toString(); s = s + tmp;
public void toString() {
String s = "";
if (x != null) {
s = s + x.toString();
}
s = s + "# ";
return s;
}
wieso gibt s wieder anstelle ? der muss doch erst dadurch gehen durch die abfragen ?Nochmal langsam:
Wenn x nun ein String wäre, sagen wir mal "S", dann würdest Du doch einfach der Reihe nach durchgehen:Java:public void toString() { String s = ""; if (x != null) { s = s + x.toString(); } s = s + "# "; return s; }
1. s := ""
2. "S" != null, also wird der then-Zweig ausgeführt
3. Methode toString() von x wird aufgerufen, die liefert "S"
4. s := s + x.toString() -> s := s + "S", also s := "S"
5. then-Zweig durch, als nächstes kommt s: = s + "# " -> s := "S" + "# " -> s := "S# "
6. s zurückgeben, also Rückgabe ist "S# "
Soweit verstanden?
der muss doch wieder durch die abfragen durch wenn er the mthode in schritt drei aufruft?
Wenn x nun ein String wäre, sagen wir mal "S"
Ja verstanden aber wie wäre es in dem Code oben ?Das ist keine Rekursion!!!
Du kannst "toString()" auch auf eine Stringvariable aufrufen. Das liefert als Ergebnis den String.
In dem Code oben ist x ein String -> nix Rekursion.Ja verstanden aber wie wäre es in dem Code oben ?
Aber dann würde er sich doch ganze Zeit aufrufen ansattt dass S returned wird da die if bedinung in deinem Falle nie ungleich null ist, weil da immer ein wert ist ?In dem Code oben ist x ein String -> nix Rekursion.
Im Schritt 3 wird die Ausführung der aktuellen Methode "unterbrochen", um die toString()-Methode auszuführen. Diese kehrt irgendwann mit einem Ergebnis (in dem Fall dem String selbst) zurück. Dann ist die Unterbrechung beendet und es wird bei Schritt 4 weitergemacht.
Ist das verstanden?
Ja.Also sprich er ist bei tostring und ruft sich dann selber auf dann heißt es ja dass er wieder die if abfrage macht
Ja.macht er es solange bis dies nicht mehr gilt
Das ist zu ungenau. Formulier das mal um.und dann gibt er die Werte raus also die Werte im linken teilbaum?
Also das weiß ich aber im Beispiel ist das ein rekursiver Aufruf mit toString und meine frage wäre wenn das Programm die rekursive Methode aufruft muss er nicht durch alle Anfragen wieder durch bevor er den wirklichen Wert returned.
19
/ \
5 25
Das ist falsch oder zumindest ungenau formuliert.dann return er alle Knoten die er durchgegangen ist in meinem Fall.
stimmt hatte ich verpeilt der geht weiter hoch. Meine Frage war nur ob er in der aufgeruften rekursivem Methode wieder die abfragen durch macht.Das ist falsch oder zumindest ungenau formuliert.
Wenn es keine weiteren Knoten mehr gibt, dann returned er mit dem Wert dieses letzten Knotens an die Aufrufstelle für diesen Knoten zurück.
Ja.Meine Frage war nur ob er in der aufgeruften rekursivem Methode wieder die abfragen durch macht.
Meine Frage war mir dass bevor er den letzten Knoten returned in teilnaum ob er alles wieder sequentiell durchgehen muss wenn er die Methode aufruft.Ja stimmt
stimmt hatte ich verpeilt der geht weiter hoch. Meine Frage war nur ob er in der aufgeruften rekursivem Methode wieder die abfragen durch macht.
Zum x. mal: ja.alles wieder sequentiell durchgehen muss wenn er die Methode aufruft.
Jo danke wieso hat einer gesagt er direkt wieder returned das hatte verwirrt ein wenigZum x. mal: ja.