public void insert(int val) {
DoubleChainedList elem = new DoubleChainedList(val);
// wenn prev == null ist, dann dann ist der ausdruck
// "elem.prev = null;" und "elem.prev = prev;"
// identisch. d.h. die fallunterscheidung ist zwar
// nicht falsch aber überflüßig
if(prev == null)
elem.prev = null;
else
elem.prev = prev;
elem.next = this;
if(prev != null) prev.next = elem;
prev = elem;
}
public void append(int val) {
DoubleChainedList elem = new DoubleChainedList(val);
// kürzer wäre hier "if(next != null) next.prev = elem;". falsch ist
// deine variante natürlich nicht
if(next == null)
;
else
next.prev = elem;
// auch hier ist nichts falsch, aber wenn wir schon einen 2. konstruktor
// definieren können wir ihn ruhig verwenden (ein paar zeilen weiter
// oben, das hätte hier 2 zeilen gespart
elem.next = next;
elem.prev = this;
this.next = elem;
}
// just a simple implementation :-)
public void delete() {
// falls wir das erste (bzw. das letzte) element der liste löschen
// wollen ist prev (bzw. next) leer, also null. zur laufzeit gibt
// das eine exception.
next.prev = prev;
prev.next = next;
}
public int length() {
int result = 0;
DoubleChainedList pointer = this.getHead();
// in unserer klasse gibt es keine leeren elemente. der pointer kann
// also gar nicht null sein, es sei denn eine der methoden ist
// fehlerhaft implementiert worden
if(pointer == null)
return result;
result++;
// da wir mit getHead zum ersten element gesprungen sind ist die
// bedingung "pointer.prev == null" immer wahr.
// da die while-schleife weiter unten onehin bei
// pointer.next == null abbricht ist die ganze if-anweisung
// eigentlich überflüßig
if( (pointer.prev == null) && (pointer.next == null) )
return result;
while( pointer.next != null) {
result++;
pointer = pointer.next;
}
return result;
}
public void reverse() {
DoubleChainedList tmp, tmpNext, pointer;
int listLength = this.length();
// einfacher wäre "pointer = getHead();"
pointer = this;
while(pointer.prev != null)
pointer = pointer.prev;
for(int i = 0; i < listLength; i++){
tmp = pointer.prev;
tmpNext = pointer.next;
pointer.prev = pointer.next;
pointer.next = tmp;
pointer = tmpNext;
}
}
// eine alternative für reverse(), der schleifenkopf ist etwas
// allerdings etwas undurchsichtiger
//
// public void reverse(){
// for(DoubleChainedList t = getHead(), temp; t != null;
// t = t.previous)
// {
// temp = t.next;
// t.next = t.previous;
// t.previous = temp;
// }
// }
public String toString() {
// hier würde sich wieder getHead anbieten...
// Anfang der Liste suchen
DoubleChainedList list = this;
while (list.prev != null)
list = list.prev;
// Liste durchlaufen und Werte an Ausgabestring anhängen
String result = "[" + list.value; // Anfange
while (list.next != null) {
result = result + ", " + list.next.value;
list = list.next;
}
return result + "]"; // Ende
}
// eine alternative zu toString():
//
// public String toString() {
// String result = "[";
// for(DoubleChainedList t = getHead(); t != null; t = t.next)
// result = result + t.info + " ";
// return result + "]";
// helper methods for the visualisation of the tests
// see DoubleChainedListTest.java
public int getValue() {
int result = value;
return result;
}
public DoubleChainedList getNext() {
return next;
}
public DoubleChainedList getPrev() {
return prev;
}
}
fazit: ein kleiner fehler in delete(), ansonsten ein lauffähiger code
grüße - hans
----------------------------------------------------------------
Im Universum, so es ein abgeschlossenes System ist, strebt die Unordnung
gegen ein Maximum.