Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Hallo. Ich habe eine Aufgabe und komm da gar nicht weiter:
1. Algorithmus entwickeln: boolean insert (Object prev, Object data), der neuen Datensatz hinter dem prev einfügvt.
2. Wenn prev nicht in der Liste ist, soll der neue DS auch nicht eingefügt werden.
3. boolean sollte true sein, wenn erfolgreich eingefügt wurde. false, wenn nicht eingefügt wurde.
public void insert(Node n)
{
Node n=head;
while( n.next !=null )
{
if(// nächste ist dein node vor dem du einfügen willst//) {
break;
}
n=n.next;
}
// ist für eine Liste wo der Header am anfang als Node(null, null ) hat
n.next=new Node(name,n.next);
}
du gehst die schleife deiner liste nicht richtig durch und der vergleich ist auch nicht nicer dicer
da jedes Objekt von der Klasse Object erbt und die die methode equals hat solltest du da mal gucken
und deine For schleife ist sehr verwirrend... mit der While schleife gehts einfacher
dein Previous knoten ist der in dem du dich befindest und dein next knoten ist aktuellerKnoten.next
public void insert(Node n)
{
Node n=head;
while( n.next !=null )
{
if(// nächste ist dein node vor dem du einfügen willst//) {
break;
}
n=n.next;
}
// ist für eine Liste wo der Header am anfang als Node(null, null ) hat
n.next=new Node(name,n.next);
}
du gehst die schleife deiner liste nicht richtig durch und der vergleich ist auch nicht nicer dicer
da jedes Objekt von der Klasse Object erbt und die die methode equals hat solltest du da mal gucken
und deine For schleife ist sehr verwirrend... mit der While schleife gehts einfacher
dein Previous knoten ist der in dem du dich befindest und dein next knoten ist aktuellerKnoten.next
Das ist also durchaus die korrekte Schleife. Deine Schleife ist aber definitiv nicht korrekt:
Java:
Node n=head;
while( n.next !=null ) {
// ...
}
Wenn head null ist (List hat keine Elemente), dann hast Du hier eine NullPointerException!
Die for Schleife ist in meinen Augen auch die traditionelle Zähl-Schleife und daher würde ich den Code auch nicht mit so einer for Schleife schreiben, aber das ändert nichts daran, dass die Schleife so erst einmal korrekt ist!
man hat da keine null pointer exception, kannst dubitte erklären wo die passieren kann?
#
Mein head is Node(null,null);
head.next ist null -> while schleife wird übersprungen
node wird hinter head eingefügt
head pointer auf den neuen node und der neue node hat als next wert null
Ja bei dir ist das schon so, aber eine LinkedList wird normaler Weise nicht mit einem leeren Node initialisiert. Das ist halt eine LinkedList mit einem leeren Node, aber nicht eine leere List.
Ja bei dir ist das schon so, aber eine LinkedList wird normaler Weise nicht mit einem leeren Node initialisiert. Das ist halt eine LinkedList mit einem leeren Node, aber nicht eine leere List.
es gibt viele Verschiedene Methoden eine Liste zu initialisieren
1. array Liste
2. mit null als head und ende
3. mit pseudo Node
usw udn sofort
ich habe einen pseudo node benutzt und es funktioniert einwandfrei falls du die liste ohne inserts ausgibst kommt auch kein Fehler weil sie "leer" ist weil der header nur den anfang der liste repräsentiert und der null pointer vom head wird immer weiter geschoben und repärsentiert das ende
Dass eine Liste von ANfang an KOMPLETT ohne alles da stehen muss hat niemand gesagt hilfsmittel kann ich ja einbauen der head ist ja das problem der liste und ist nach aussen hin auch nicht sichtbar oder hat einen effekt ob ich es mit head mach oder ohne es geht darum sachen einzufügen oder sonst was zu machen und solange das richtig ist sollte es auch kein problem darstellen
Das ist Schmarn. Wie willst du einen Pseudo Node von einem Node unterscheiden, der tatsächlich keinen Wert hat.
Stell dir vor du hast einen Karawanenführer von Kamelen. Hat er kein Kamel so ist seine Karawane leer, er hat keinen Zügel in der Hand (head). Das ist doch nicht das gleiche wie eine Karawane bestehend aus einem Kamel, welches aber nichts trägt.
Bitte, wer auch immer dir die Idee von dem Pseudo Node in den Kopf gepflanzt hat, streiche sie wieder.
du verstehst nicht was ich mit dem pseudo knoten erreiche...
wenn du schon dieses Beispiel haben willst
dann insert(1)
also 1 kamel hast
und du gibst dir alle listen elemente aus wie viele hast du dann?
auch nur 1 in der Ausgabe
Es geht mir nicht darum was du in der Ausgabe siehst, sondern was du physisch hast.
Wenn du mit dem Kamel beginnst, welches nicht trägst hast du immernoch eine Karawane der Länge 1. Dieses Kamel beim Zählen und beim Betrachten (Ausgabe) zu ignorieren ist nur eine Verschleierung dessen.
Das ist darüber hinaus, wärest du im Berufsleben, für andere kaum nachvollziehbar und sehr fehleranfällig.
Dir ist also auch egal, dass dieses Kamel Speicher belegt? Ach egal, ich mag nimmer versuchen dir hier die Nachteile dessen aufzuzeigen. Over and out. Schönes Wochenende.
Ich würde es einfach einmal so nachfragen:
Wo siehst Du den Vorteil eines solchen Dummy Nodes?
Er erhöht auf jeden Fall die Komplexität bei allen Operationen und macht Code schlechter lesbar.
Als Beispiel reicht ja schon diese Methode als Beispiel:
Das Objekt in n interessiert nicht. Es interessiert eigentlich nur n.next.
Oder eine andere Argumentation:
Generell könntest Du auch den Code überall umschreiben. Da head nur auf einen Dummy-Node verweist, in dem immer nur next gesetzt oder verwendet wird, könntest Du überall statt auf Head direkt auf head.next zugreifen.
Also aus der Methode oben würde man dann so erhalten:
Java:
public void readList() {
Node n=head.next;
while( n !=null )
{
System.out.println(n.counter);
n= n.next;
}
}
Aber vielleicht übersehe ich ja irgend einen Grund, etwas so zu bauen?
Und falls Du in einem Kurs mit dem TE bist, dann kann sowas in der Art sogar Teil der Aufgabe sein. Selbst das möchte ich nicht ausschließen. Ich habe schon genug gesehen, so dass ich etwas in der Art nicht ausschließen würde.
Eine "normale" Liste hat als head einen Node auf den ein Null pointer zielt als vorgägner und der musste immer im nachhinein umgeändert werden ( so hatte ich es gelernt ka ob das schon grampf war)
durch den Dummy fällt das Umlenken des Endes und des Anfangs weg weil der Dummy Knoten schon die Information des Anfangs (Das Objekt ist null und kann nicht mehr in der Liste vorkommen..falls ich es mit generics gesichert hätte) und das ende ist auch schon dabei weil head.next = null einfach weiter gegeben wird an den Node der das Ende macht
KA Ob das Überzeugend ist oder Schwachsinnig nur so hatte ich es gelernt... man macht ja immer alles den alten nach
und die Verbesserung mit n=head.next find ich sehr gut muss ich gleich übernehmen
Eine "normale" Liste hat als head einen Node auf den ein Null pointer zielt als vorgägner und der musste immer im nachhinein umgeändert ( so hatte ich es gelernt ka ob das schon grampf war)
durch den Dummy fällt das Umlenken des Endes und des Anfangs weg weil der Dummy Knoten schon die Information des Anfangs (Das Objekt ist null und kann nicht mehr in der Liste vorkommen..falls ich es mit generics gesichert hätte) und das ende ist auch schon dabei weil head.next = null einfach weiter gegeben wird an den Node der das Ende macht
Generell hast Du eine Referenz zu ändern, wenn der head sich ändert. Nur einmal ist das head und mit Dummy-Knoten ist s next im Dummy-Knoten.
Man könnte jetzt maximal überlegen, ob es die Sonderfälle reduziert, dadurch dass ich den head als normalen Node verändern kann. Es kann also den Code bei den Sonderfällen schöner machen. Also was man nicht mehr braucht ist sowas wie:
Java:
Node newNode = new Node(.....);
if (head == null) {
head = newNode;
} else {
getLastNode().next = newNode;
}
So etwas könnte dann evtl. ein Grund dafür sein. Das müsste man sich einmal im Detail aufschreiben und schauen, was das bedeutet. Und dann könnte man auch schauen, ob man das nicht auf andere Art ebenso hin bekommen kann.
Wenn etwas in der Art notwendig ist, dann könnte man sich überlegen, ob es nicht komplett bei einer Klasse bleiben kann. Die Nodes sind dann auch List Instanzen. Der Listenkopf hat dann halt einfach keine Daten. Die public Methoden von List wandern in Node und alles andere in Node ist private.
Oder in andern Worten: Die Referenz auf List ist schon die Referenz auf den "Dummy Node".
Prinzipiell kann man aber auch schauen, ob da evtl. ein Interface oder so Sinn machen kann - dann hat man einfach ein Verhalten, mit dem man getNext und setNext erhält. Das wäre etwas, über das man auch nachdenken könnte.
Aber ich muss mich wiederholen: Das müsste man im Detail sehen um das zu bewerten. Also obwohl ich jetzt ein kleinen Grund dafür gefunden habe, sehe ich das immer noch nicht anders. (Aber das ist ja auch nicht so, dass es hier um richtig oder falsch geht. Bei dem Code schrillen bei mir aber zumindest die Alarmglocken - der Dummy Node erklärt, dass es kein problem ist, aber aus Clean Code Sicht ist es unschön, weil eben auf sowas geachtet wird....
Und Du hast dem TE so geantwortet, dass der Verdacht aufgekommen ist, dass Du die Aufgabe / den TE evtl. im Detail kennst (Vielleicht hat er ja genau so eine Liste vorgegeben, wie Du diese skizziert hast).
Aber das sind ja zwei Punkte - einmal das Thema vom TE und dann Dein Hinweis, den ich und Moxxi als Anlass für weitere Hinweise gesehen haben.
Nungut, beide Listen hätten eine Lösung geboten für die Frage des TE
dass man das "previous" im sinne von vorgängern nicht braucht/hat ( falls der TE keine Doppelt verlinkte Liste hat ) sollte klar geworden sein
und das Grund Prinzip von n.next sollte auch erkennbar sein egal mit oder ohne Pseudo Knoten