Hi zusammen,
könnte mir jemand diesen Konstruktor erläutern?
public SortedListGen() {
DListNode<E> dummy = new DListNode<E>();
dummy.next = dummy;
dummy.prev = dummy;
head = dummy;
current = dummy;
}
vor allem die Methode : private E delete().... funktioniert in meinen Augen nicht, weil ja durrent immer auf ein dummy zeigt, und damit erst gar
nicht ausgeführt werden kann?
Ich kann nicht ganz nachvollziehen, welchen Zweck die dummys haben? und warum head und current auf diese zeigen.
danke!
hier vorsorglich mal der gesamte Code der classe bis auf die Interfaces und die exceptionsklasse...
EDIT: die Methode funktioniert! man muss nur zuvor schon einaml eine andere methode wie z.b. contains (o) benutzen, da mit sich der current zeiger auch bewegt.
das mit den dummys hab ich aber noch immer nicht verstanden
könnte mir jemand diesen Konstruktor erläutern?
public SortedListGen() {
DListNode<E> dummy = new DListNode<E>();
dummy.next = dummy;
dummy.prev = dummy;
head = dummy;
current = dummy;
}
vor allem die Methode : private E delete().... funktioniert in meinen Augen nicht, weil ja durrent immer auf ein dummy zeigt, und damit erst gar
nicht ausgeführt werden kann?
Ich kann nicht ganz nachvollziehen, welchen Zweck die dummys haben? und warum head und current auf diese zeigen.
danke!
hier vorsorglich mal der gesamte Code der classe bis auf die Interfaces und die exceptionsklasse...
Code:
public class SortedListGen<E extends Comparable<? super E>> implements
DynamicSetGen<E> {
DListNode<E> head;
DListNode<E> current;
/**
* Erzeugt eine doppelt-verkettete Zirkularliste mit einem Dummy-Knoten, der
* auf sich selber zeigt.
*/
public SortedListGen() {
DListNode<E> dummy = new DListNode<E>();
dummy.next = dummy;
dummy.prev = dummy;
head = dummy;
current = dummy;
}
/**
* Liefert zurueck, ob die Liste leer ist.
*
* @return <code>boolean</code>
*/
public boolean isEmpty() {
return head.next == head;
}
/**
* Leert die Liste.
*/
public void empty() {
head.next = head;
head.prev = head;
}
/**
* Liefert zurueck, ob der current-Zeiger auf ein gueltiges Element zeigt.
*
* @return <code>boolean</code>
*/
private boolean current_in_list() {
return (!isEmpty() && current != head);
}
/**
* Loescht das Element, auf das <code>current</code> zeigt, aus der Liste,
* setzt current auf den Anfang der Liste zurueck und liefert das geloeschte
* Element zurueck.
*
* @return <code>element</code>
* @throws EmptySetException
*/
public E delete() throws EmptySetException {
E o = null;
if (current_in_list()) {
o = current.element;
current.prev.next = current.next;
current.next.prev = current.prev;
current = head;
} else
throw new EmptySetException(
"Das Objekt konnte nicht gelöscht werden");
return o;
}
/**
* Loescht das erste Element der Liste und liefert es zurueck.
*
* @return <code>element</code>
* @throws ListEmptyException
*/
public E removeFirst() throws EmptySetException {
if (isEmpty())
throw new EmptySetException(
"It was not posible to remove the first element because "
+ "the list is empty");
E element = head.next.element;
head.next = head.next.next;
head.next.prev = head;
return element;
}
/**
* Fuegt das uebergebene Element so ein, dass die Liste sortiert bleibt.
*
* @param element
* - das uebergebene Element
*/
public void insert(E element) {
DListNode<E> newElement = new DListNode<E>(element);
if (isEmpty()) {
insertNode(head, newElement);
} else {
DListNode<E> temp = head;
while ((temp.next != head)
&& ((newElement.element).compareTo(temp.next.element) > 0)) {
// richtiger Platz gefunden
temp = temp.next;
}
insertNode(temp, newElement);
} // end of if
} // end of add
/**
* Fuegt das uebergebene Knoten-Element node in die Liste nach
* <code>pos</code> ein.
*
* @param pos
* - die Position zum einfuegen
* @param node
* - das Element, dass eingefuegt wird
*/
private void insertNode(DListNode<E> pos, DListNode<E> node) {
node.prev = pos;
node.next = pos.next;
pos.next = node;
node.next.prev = node;
}
/**
* Prueft, ob die Liste das uebergebene Element enthaelt und liefert das
* Ergebnis als Wahrheitswert zurueck. Wenn ja, wird current auf das
* gesuchte Element gesetzt und true zurueck geliefert. Wenn nein, wird
* false zurueck geliefert.
*
* @param o
* das uebergebene Element
* @return <code>boolean</code>
*/
public boolean contains(E o) {
// einfacher Fall beseitigen
if (isEmpty())
return false;
current = head.next; // die Suche am Anfang der Liste starten
E elem = current.element;
// die Tatsache, dass die Liste sortiert ist, wird hier benutzt
while ((current != head) && elem.compareTo(o) < 0) {
current = current.next;
elem = current.element;
}
if (elem.compareTo(o) == 0) {
return true;
} else {
return false; // wir verlassen die Methode
// das aktuelle Element ist groesser als o
}
}
/**
* Liefert eine String-Repraesentation der Liste zurueck.
*
* @return <code>String</code>
*/
public String toString() {
String ss = "Liste: ";
if (isEmpty())
return ss + "Empty";
else {
DListNode<E> temp = head.next;
do {
ss = ss + " " + temp.element.toString();
temp = temp.next;
} while (temp != head);
}
ss = ss + "\n";
return ss;
}
/**
* Gibt eine String-Repraesentation der Liste zur Konsole aus.
*
*/
public void print() {
System.out.println(toString());
}
/**
* Liefert die Anzahl der Elemente in der Liste zurueck.
*
* @return <code>int</code>
*/
public int size() {
int counter = 0;
DListNode<E> temp = head;
if (!isEmpty()) {
while (temp.next != head) {
++counter;
temp = temp.next;
}
} // end of if
return counter;
}
// innere Klasse DListNode
private class DListNode<E extends Comparable<? super E>> {
private E element;
private DListNode<E> next;
private DListNode<E> prev;
private DListNode(E e) {
element = e;
next = null;
prev = null;
}
private DListNode() {
this(null);
}
}
public static void main (String[] args) throws EmptySetException {
SortedListGen<String> neueListe = new SortedListGen<>();
System.out.println(neueListe.current_in_list());
neueListe.insert("ABC1");
neueListe.insert("ABC2");
neueListe.insert("ABC3");
neueListe.insert("ABC4");
neueListe.print();
System.out.println(neueListe.isEmpty());
System.out.println(neueListe.current_in_list());
// System.out.println(neueListe.size());
// neueListe.print();
// neueListe.delete();
// System.out.println(neueListe.size());
// System.out.println(neueListe.current_in_list());
// neueListe.print();
}
} // end of class SortedListEDIT: die Methode funktioniert! man muss nur zuvor schon einaml eine andere methode wie z.b. contains (o) benutzen, da mit sich der current zeiger auch bewegt.
das mit den dummys hab ich aber noch immer nicht verstanden
Zuletzt bearbeitet:
