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.
Hey Leute,
mal ne frage zu Listen , wie erkenne ich ob ich in der while( a!=Null) schauen muss oder while (a.nächster!=Null)?
Das ist mir noch etwas unschlüssig. Schaut mal im anhang dort sind 3 Methoden , 2 davon habe ich mit a!=null und eine mit a.nächster
public class Link {
public int wert ;
public Link nächster;
public Link(int wert , Link nächster) {
this.wert=wert;
this.nächster=nächster;
}
}
public class Liste {
public Link anfang;
public Link ende;
public Liste(Link anfang) {
this.anfang = anfang;
this.ende = anfang;
}
public void add(Link neu) {
if (this.anfang == null) {
this.anfang = neu;
this.ende=neu;
} else {
this.ende.nächster = neu;
ende = ende.nächster;
}
}
public void iter() {
Link a = anfang;
while (a != null) {
System.out.print(a.wert + " ");
a = a.nächster;
}
}
public void anzEl() {
Link a = anfang;
int count = 0;
while (a != null) {
++count;
a = a.nächster;
}
System.out.println("Die liste besitzt " + count + " an Elementen");
}
public void fügeWertein(int value) {
Link neu = new Link(value, null);
Link a = anfang;
while (a.nächster != null) {
if (a.wert == value) {
System.out.println("Wert ist schon vorhanden");
return;
}
a = a.nächster;
}
a.nächster = neu;
}
Das ist dann der Code in Code Tags Was meien spezifische Frage ist , steht ja Anfangs
Also ein grober Unterschied ist:
Mit a != null läufst du komplett durch und am Ende ist a halt null.
Ist ok, wenn du alle Elemente einmal anpacken willst.
Mit a.next != null läufst du nur bis zum letzten Element. A ist dann nicht null sondern das letzte Element.
Also bei letzter Variante bleibst du beim Vorgänger stehen. In einer einfach verketteten Liste ist dies notwendig, wenn man den Vorgänger auch benötigt um z.B. da den next Wert anzupassen.
Also ein grober Unterschied ist:
Mit a != null läufst du komplett durch und am Ende ist a halt null.
Ist ok, wenn du alle Elemente einmal anpacken willst.
Mit a.next != null läufst du nur bis zum letzten Element. A ist dann nicht null sondern das letzte Element.
Also bei letzter Variante bleibst du beim Vorgänger stehen. In einer einfach verketteten Liste ist dies notwendig, wenn man den Vorgänger auch benötigt um z.B. da den next Wert anzupassen.
also , wenn ich durchlaufe beim durchlaufen zB die Elemente zählen möchte , a.wert ausgeben oder einfach nur ein Wertevergleich machen möchte dann laufe ich einmal komplett durch die liste durch mit a!= null?
Bei welche Operationen läuft man in der while zb(a.nächster!=null)?
Ja genau. Einfügen gehst du z.B. so lange durch, bis a.next == null ist oder a.next.wert so ist, dass der neue Wert davor kommen soll.
Aber vorsichtshalber noch die Bemerkung: Das ist natürlich nur eine Lösung. Man kann z.B. auch mit a != null und so prüfen und sich den Vorgänger merken. Also mit zusätzlicher Variable und so. Es gibt also oft mehrere Lösungsideen. Aber diese Alternative Lösung hat z.B. mehr code. Was einem besser gefällt muss jeder für sich entscheiden.
Ja, da hast du Recht. Wenn du bereits die notwendigen Elemente zur Hand hast, dann brauchst du das nicht.
Anfang ist immer klar, denn du hast ja den Zeiger auf das erste Element.
Das letzte Element hält man nicht zwingend vor. Das zu speichern ist somit eine Optimierung. Wenn du das letzte Element schon hast, musst du nicht mehr durch die Liste durch gehen.
In "nächster" steckt ja das Element, welches auf das aktuelle Element folgt. Einmal schaust du also, ob das aktuelle Element null ist, dann bist du am Ende angekommen. Im anderen Fall, schaust du, ob es nach dem aktuellen Element noch ein weiteres gibt (a.next != null).
Was meien spezifische Frage ist , steht ja Anfangs
