Hallo Leute!
Ich hab ein riesiges Problem. Ich soll von einer normalen LinkedList abgeleitet eine DoublyLinkedList erstellen und alle Funktionen neu machen die ich brauche. So vor und zurück hüpfen funktioniert, genauso wie das suchen, aber wenn ich einen neuen Knoten einfügen will (bis jetzt nur mit InsertAfter probiert) macht er das zwar, setzt mir aber keine Zeiger in dem Knoten auf den Vorgänger wie auch Nachfolger. Ich bin hier echt am verzweifeln, weil jetzt neuerdings meine deleteAfter Funktion auch noch beim compilieren rummeckert. :cry: Bitte helft mir ! *ganzLiebschau*
Ich hab ein riesiges Problem. Ich soll von einer normalen LinkedList abgeleitet eine DoublyLinkedList erstellen und alle Funktionen neu machen die ich brauche. So vor und zurück hüpfen funktioniert, genauso wie das suchen, aber wenn ich einen neuen Knoten einfügen will (bis jetzt nur mit InsertAfter probiert) macht er das zwar, setzt mir aber keine Zeiger in dem Knoten auf den Vorgänger wie auch Nachfolger. Ich bin hier echt am verzweifeln, weil jetzt neuerdings meine deleteAfter Funktion auch noch beim compilieren rummeckert. :cry: Bitte helft mir ! *ganzLiebschau*
Code:
package Lists;
public class DoublyLinkedList extends List {
//Andere Anweisungen die die Strucktur der Liste verändern und deshalb überschrieben werden müssen
public void insertAfter(Object val) {
if (hasActListnode() && cursor != Last) {
//neuer Listenknoten mit den Inhalt val, einen Zeiger auf den nächsten und vorherigen
cursor.next = new DLListnode(val, cursor.next, ((DLListnode) cursor).pred); //
System.out.println("InsertAfter:" +val); //Abfrage
}
else if (isEmpty())
cursor = first = Last = new DLListnode (val, null, null);
else if (cursor == Last) {
cursor.next = Last = new DLListnode(val, null, ((DLListnode) cursor).pred); //
System.out.println("InsertAfter:" +val); //Abfrage
}
else System.out.println ("Es kann kein Eintrag eingefügt werden...");
}
public void insertBefore (Object val) {
if (hasActListnode()) {
//neuer Listenknoten mit den Inhalt val, einen Zeiger auf den nächsten und vorherigen
//((DLListnode) cursor).pred) = new DLListnode(cursor.val, cursor.next, ((DLListnode) cursor).pred);
cursor.next = new DLListnode(cursor.val, cursor.next, ((DLListnode) cursor).pred);
cursor.val = val;
System.out.println ("InsertBefore:" +val); //Abfrage
}
else if (isEmpty())
cursor = first = Last = new DLListnode (val, null, null);
else System.out.println ("Es kann kein Eintrag eingefügt werden...");
}
public void deleteAfter() {
if (existActListnodeSuccessor()) {
Listnode del = cursor.next;
cursor.next = cursor.next.next;
if (cursor == first)
((DLListnode) cursor).pred = null;
del.next = null;
}
else System.out.println("Es kann kein Eintrag gelöscht werden...");
}
public void deleteFirst() {
if (!isEmpty()) {
if (cursor == first)
cursor = null;
Listnode del = first;
first = first.next;
((DLListnode) first).pred = null;
//gelöschten Listenknoten isolieren
del.next = null;
}
else System.out.println("Die Liste ist leer.");
}
public void delete() {
if (existActListnodeSuccessor()) {
cursor.val = cursor.next.val;
Listnode del = cursor.next;
cursor.next = cursor.next.next;
((DLListnode) cursor).pred = ((DLListnode) cursor).pred.pred;
del.next = null;
}
else System.out.println("Der aktuelle Listenknoten kann nicht gelöscht werden.");
}
public DoublyLinkedList () {
//Konstruiert eine leere doppelt verkettete Liste
}
// Festlegung des aktullen Listenknotens
// letzter Listenknoten
public void last() {
cursor = Last;
}
// vorheriger Listenknoten
public void pred() {
if (hasActListnode())
cursor = ((DLListnode) cursor).pred;
else if (cursor == first)
System.out.println("Es konnte kein Vörgänger gefunden werden bzw. der Cursor steht auf dem ersten Eintrag ...");
else
System.out.println ("Kein Listenknoten...");
}
protected class DLListnode extends Listnode { //
public DLListnode (Object val, Listnode next, DLListnode pred) {
super(val, next);
this.pred = pred;
}
DLListnode pred = null;
} //DLListnode Ende
//Zugriff auf die Info - Komponenten
//Zugriff auf den Vorgänger des aktuellen Knotens
public Object getValPred() {
return existActListnodePredecessor()
? ((DLListnode) cursor).pred.val : null;
}
//Ersetzung des Vorgängers des aktuellen Knotens
public void setValPred(Object val) {
if (existActListnodePredecessor())
((DLListnode) cursor).pred.val = val;
else
System.out.println ("Es existiert kein Vorgänger des aktuellen Knotens...");
}
// Verarbeitung der Info - Komponenten aller Listenknoten
public void processListnodesReverse() { //verarbeite die Einträge von hinten nach vorne
for (DLListnode current=Last; current != null; current=((DLListnode) current).pred)
current.process();
}
public void findReverse(Object val) { //finde einen Eintrag vom letzten zum ersten gehend
for (; cursor != null && !cursor.val.equals(val);cursor=((DLListnode) cursor).pred);
}
//Eigenschaften der Liste
public boolean existActListnodePredecessor() { //existiert ein Vörgänger?
return hasActListnode() && ((DLListnode) cursor).pred != null;
}
// Löschen des letzten Listenknotens
public void deleteLast() {
if (!isEmpty()) {
if (cursor == Last)
cursor = null;
DLListnode del = Last;
Last = Last.pred;
Last.next = null;
//gelöschten Listenknoten isolieren
del.pred = null;
}
else
System.out.println ("Die Liste ist leer...");
}
protected DLListnode Last = null; //letzer Knoten
}
