Verkette Liste

[thor_norsk]

Guten Abend, ich verstehe die Aufgabe nicht richtig.


[CODE lang="java" title="Verkette Liste"]class Listenelement {

// Instanzvariable
String daten;
Listenelement naechster;

void setDaten (String datenNeue) {

daten = datenNeue;
naechster = null;
}

void anhaengen(String datenNeu) {

if (naechster == null) {

naechster = new Listenelement();
naechster.setDaten(datenNeu);
}
else
naechster.anhaengen(datenNeu);
System.out.println("Daten\t"+datenNeu+"\t wurden eingefügt.");

}

void ausgeben() {

System.out.println(daten);
if (naechster != null)
naechster.ausgeben();
}
}

public class ListeV3 {

public static void main(String[] args) {

Listenelement listenAnfang = new Listenelement();
listenAnfang.setDaten("Element1");

for (int element = 2; element < 4; element++)

listenAnfang.anhaengen("Element"+element);
listenAnfang.ausgeben();
}
}
[/CODE]

Ich versuche meine Gedanken zu spiegeln.
Frage 1) 2 Instanzvariablen werden vereinbart. String daten & Listenelement naechster und warum nicht String naechster ???

Jetzt versuche ich von der Methode main() aus, die Ausgabe zu erklären, die ich nicht richtig verstehe.

Neues Listenelement wird erzeugt : listenAnfang : Instanz der Klasse Listenelement
listenAnfang.setDaten("Element1"); führt zum Ergebnis: daten = "Element1" und naechster = null, somit wird listenAnfang der Wert ""Element1" zugewiesen.

Also: listenAnfang = "Element 1" & naechster = null; zur der Zeitpunkt?

Bevor ich mit der for - Schleife beginne, zeige ich euch die Ausgabe.

Daten Element2 wurden eingefügt.
Daten Element3 wurden eingefügt.
Daten Element3 wurden eingefügt.
Element1
Element2
Element3

ich verstehe nicht warum bei der for - Schleife die else Zweig ausgeführt wird, obwohl naechster = null ist ?
Es wäre sehr nett, wenn jemand mit einfachen Wörtern erklären könnte. Vor Allem wird die Methode wieder rekursiv wieder aufgerufen.

Ich bedanke mich im Voraus.

 

[Mart]

    void anhaengen(String datenNeu) {
    
    if (naechster == null) {           
        
        naechster = new Listenelement();     
        naechster.setDaten(datenNeu);       
        }
     else                             
        naechster.anhaengen(datenNeu);                           
        System.out.println("Daten\t"+datenNeu+"\t wurden eingefügt.");             
                                                                            
    }

die ausgabe passt nicht du hängst nur ein wenn der nächste null ist ansonsten latscht du weiter
weiter hab ichs noch incht angeschaut

 

[Jw456]

1.) das ist eine Referenz Instanz auf ein neues Objekt von deiner Klasse.
Das wird ja bei anhängen mit new erstellt.

Bein anhägen wird ein neues Objekt erstellt dem alten Objekt (das in dem du gerade bist ) wird die neue ref übergeben. In den neuen Objekt wird der Sting gespeichert der dann keine ref hat.

 

[thor_norsk]

Die Methode ausgeben() ist ok . Wird solange rekursiv ausgeführt bis das letzte Element = null ist, was Listenende bedeutet nach meiner auffassung.

 

[kneitzel]

Frage 1) 2 Instanzvariablen werden vereinbart. String daten & Listenelement naechster und warum nicht String naechster ???

Weil Du eine Liste von mehreren Elementen haben willst. wenn naechster ein String wäre, dann könnte da nur ein String stehen- Aber Du willst ja vielleicht 100 Strings in der Liste haben. Und das geht dann nur mit einer dynamischen Anzahl Listenelemente.

Du hast Waggons, die fahren können. Wenn Du einen ersten Zug haben willst, musst Du einfach einen ersten Waggon nehmen (Listenelement) und das ist Dein Zuganfang (Listenanfang). Und den Container (Den String, den Du speichern kannst) kannst Du dann auf den Waggon laden.
Wenn Du nun noch einen Container mitnehmen willst, dann musst Du ans Ende des Zuges gehen, da einen neuen Waggon anhängen und da dann den Container aufladen.
Aber Du hängst natürlich hinten an den Waggon nur andere Waggons und nicht direkt einen Container!

 

[Mart]

Die Methode ausgeben() ist ok . Wird solange rekursiv ausgeführt bis das letzte Element = null ist, was Listenende bedeutet nach meiner auffassung.

ivh habe mich auch über anhaengen beschwwert

 

[kneitzel]

Die Methode ausgeben() ist ok . Wird solange rekursiv ausgeführt bis das letzte Element = null ist, was Listenende bedeutet nach meiner auffassung.

Es geht um die Methode anhaengen, die bemängelt wurde.

 

[Jw456]

bei dem else bist du im neuen Objekt und brauchst nur den sting speichern

 

[kneitzel]

Ich verstehe nicht warum bei der for - Schleife die else Zweig ausgeführt wird, obwohl naechster = null ist ?

naechster ist nur am Ende null. Du setzt doch beim Anhängen das naechster des letzten Elements auf das neue Listenelement:
naechster = new Listenelement();

 

[Jw456]

if (naechster == null) {          
       
        naechster = new Listenelement();    
        naechster.setDaten(datenNeu);      
        }
     else                            
        daten = datenNeu;                          
        System.out.println("Daten\t"+datenNeu+"\t wurden eingefügt.");            
                                                                           
    }

 

[thor_norsk]

Also wenn ich richtig verstanden habe, dadurch dass ich Listenelement naechster vereinbart habe kann ich mehrere Elemente speichern?
Wahrscheinlich sind dann in der if(..) wenn ich jedes Mal naechster = new Listenelement() erzeuge sind es verschiede naechster?
Schwer zu erklären. Ich mein am Ende habe ich zum Beispiel 5 Mal naechster mit verschiedenen Werte ?
Z.B.
naechster = new Listenelement();
neachster.setDaten(datenNeu); hat den Wert "Element2" // Also es sind Referenzen (kopie des Originals?) Original ist
// Listenelement naechster; ?

nächste Runde:
naechster = new Listenelement();
neachster.setDaten(datenNeu); hat den Wert "Element3" // naechster Referenz von Original

nächste Runde:

naechster = new Listenelement();
neachster.setDaten(datenNeu); hat den Wert "Element4" // wie oben

Usw.

Also der Compiler weiß Bescheid, dass naechster = " Element2" (Referenz), dann wieder naechster="Element3" (Referenz)usw.

Mathematisch schlecht beschrieben :

// (1,2,3,n) sind interne vermerke vom Compiler, damit der Compiler die von einander unterscheiden kann ?
Listenelement naechster = { naechster(1), naechster(2), naechster(3), naechster(n)};

Ich hoffe, ich könnte euch meine Gedanken wiedergeben.

 

[Jw456]

Ja das ist eine Liste. Davon reden wir doch die ganze Zeit.
Die Liste entsteht im Speicher.

 

[Mart]

Also wenn ich richtig verstanden habe, dadurch dass ich Listenelement naechster vereinbart habe kann ich mehrere Elemente speichern?
Wahrscheinlich sind dann in der if(..) wenn ich jedes Mal naechster = new Listenelement() erzeuge sind es verschiede naechster?
Schwer zu erklären. Ich mein am Ende habe ich zum Beispiel 5 Mal naechster mit verschiedenen Werte ?
Z.B.
naechster = new Listenelement();
neachster.setDaten(datenNeu); hat den Wert "Element2" // Also es sind Referenzen (kopie des Originals?) Original ist
// Listenelement naechster; ?

nächste Runde:
naechster = new Listenelement();
neachster.setDaten(datenNeu); hat den Wert "Element3" // naechster Referenz von Original

nächste Runde:

naechster = new Listenelement();
neachster.setDaten(datenNeu); hat den Wert "Element4" // wie oben

Usw.

Also der Compiler weiß Bescheid, dass naechster = " Element2" (Referenz), dann wieder naechster="Element3" (Referenz)usw.

Mathematisch schlecht beschrieben :

// (1,2,3,n) sind interne vermerke vom Compiler, damit der Compiler die von einander unterscheiden kann ?
Listenelement naechster = { naechster(1), naechster(2), naechster(3), naechster(n)};

Ich hoffe, ich könnte euch meine Gedanken wiedergeben.

trotz alledem hast du in dem if nen fehler, da dein system.out.println an der stelle keinen sinn ergibt ->

du gibst ne falsche ausgabe aus

 

[thor_norsk]

Ok. Danke.

 

[thor_norsk]

Wo liegt der Fehler in der if - Anweisung ?

 

[thor_norsk]

Was mich persönlich ärgert und was mir auch Schwierigkeit breitet, dass bei der Methode anhaengen() in dem else Zweig, wird die Methode rekursiv aufgerufen und dann System.out....... Ich frage mich? Wenn die Methode rekursiv aufgerufen wird, dann darf System.out.println nicht mehr aufgerufen werden oder ?

 

[Jw456]

Zeige uns doch erst noch mal wie dein Code jetzt ausschaut schwierig bei dem durcheinander und keiner weiß genau was du nun alles verändert hast

 

[Jw456]

Dein nechster.anhaengen in den Else Zweig ist aucha falsch. Habe ich dir auch schon gegeben.

 

[thor_norsk]

[CODE lang="java" title="Verkette Liste"]void anhaengen(String datenNeu) {

if (naechster == null) {

naechster = new Listenelement();
naechster.setDaten(datenNeu);
}
else
naechster.anhaengen(datenNeu); //Durch rekursiver Aufruf dürfte System.out.... nicht ausgeführt werden oder ?
System.out.println("Daten\t"+datenNeu+"\t wurden eingefügt.");
}[/CODE]

 

[Jw456]

Schaue post #10

Ok ist falsch

 

[thor_norsk]

Wie wäre denn richtig ? In meinem Skript wird darauf hingewiesen, man muss richtig hin gucken ich sehe irgendwie nichts

 

[Jw456]

In post 10 ist doch schon alles gesagt. Vergeiche den Else Zweig mit deinem.

Ok ist Falsch

 

[Jw456]

Da ist keine rekursion notwendig.

 

[Jw456]

daten = datenNeu;

Reicht kein rekursions Aufruf

Ok ist falsch

 

[thor_norsk]

Was ist Post 10 ?

 

[Jw456]

#10 ist die Nummer die immer bei jedem Post Beitrag mit da steht geht bei #1 los

 

[Jw456]

Ok bei deinem Code ist eigentlich nur die Ausgabe falsch.
Du willst ja erstmal die Kette bis zum Ende duchgehen und dann anhängen.

Also ist dein Code ok lasse das mit der Ausgabe weg.

Wenn dann gehört die Ausgabe in den if Zweig

 

[thor_norsk]

Habe ich mein Code geändert. Jetzt sieht die Ausgabe besser aus .