Hallo Forum
Ich habe die Aufgabe ohne zur Hilfenahme von üblichen fertigen Java Klassenbibliotheken eine doppelt verkettete Liste zu erzeugen.
Folgende Eigenschaften soll sie haben:
Generisches Listenobjekt erzeugen
Elemente hinzufügen
Elemente löschen
Elemente ausgeben
Soweit habe ich das fast alles fertig, aber ich komme nicht die Sache mit dem Löschen des letzten Elements innerhalb der Liste hin. Kann mir bitte jemand erklären, was ich da richtig machen muß?
Vieeelen Dank,
Semo
Ich habe die Aufgabe ohne zur Hilfenahme von üblichen fertigen Java Klassenbibliotheken eine doppelt verkettete Liste zu erzeugen.
Folgende Eigenschaften soll sie haben:
Generisches Listenobjekt erzeugen
Elemente hinzufügen
Elemente löschen
Elemente ausgeben
Soweit habe ich das fast alles fertig, aber ich komme nicht die Sache mit dem Löschen des letzten Elements innerhalb der Liste hin. Kann mir bitte jemand erklären, was ich da richtig machen muß?
Java:
import java.util.EmptyStackException;
/**
* SortedList ist ein Programm, mit dem beliebige Typen bzw. Werte in eine
* aufsteigend sortierte Liste eingebettet werden koennen
*
* @author Icke
* @version 1.6.0_20-b02
* @serial 0.3
* @param <T>
* ist ein beliebiger primitiver oder Objekttyp
*/
public class SortedList<T extends Comparable<T>> {
public Node head = null;
public Node tail = null;
class Node {
public T value;
public Node next;
public Node previous;
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
public Node getPrevious() {
return previous;
}
public void setPrevious(Node previous) {
this.previous = previous;
}
public Node(T value, Node next, Node previous) {
this.value = value;
this.next = next;
this.previous = previous;
}
}
/**
* Methode add(T elem) zum Hinzufuegen eines Wertes in eine gemaess
* Comparable aufsteigend sortierte Liste. Dubletten sind zulaessig,
* erzeugen aber kein neues Objekt, aber eine weitere interne Referenz.
*
* @param T
* elem der hinzuzufuegende Wert
*/
public void add(T elem) {
Node Lesekopf = head;
Node Knoten = new Node(elem, null, null);
// ### Wenn die Liste nicht leer ist...
if (!empty()) {
// Lesekopf-Value ist kleiner als Elem --> soll solange iterieren
// bis das letztes Obj erreicht ist
while ((Lesekopf != null)
&& (Lesekopf.getValue().compareTo(elem) < 0)) {
Lesekopf = Lesekopf.getNext();
}
// ### Wenn Lesekopf vor dem ersten Elem was einfuegen muss ###
if (Lesekopf == head) {
Knoten.setNext(Lesekopf);
Lesekopf.setPrevious(Knoten);
head = Knoten;
System.out
.println("### Wenn Lesekopf vor dem ersten Elem was einfuegen muss ###: "
+ Knoten.getValue());
}
// ### Wenn Lesekopf nach letztem Elem was einfuegen muss ###
else if (Lesekopf == null) {
// Setze Link auf auf neuen nachfolgenden Knoten
tail.setNext(Knoten);
// Setze im neuen Knoten den Vorgaenger
Knoten.setPrevious(tail);
// Setze im neuen Knoten den Nachfolger --> kein weiteres Elem
tail = Knoten;
System.out
.println("### Wenn Lesekopf nach letztem Elem was einfuegen muss ###: "
+ Knoten.getValue());
} else {
// Hole den vorletzen Knoten und biege auf neuen Knoten
Lesekopf.getPrevious().setNext(Knoten);
// Setze im neuen Knoten den Vorgaenger
Knoten.setPrevious(Lesekopf.getPrevious());
// Biege Vorgaengerkante auf neuen Vorgaenger um
Lesekopf.setPrevious(Knoten);
// Setze im neuen Knoten den Nachfolger --> Lesekopf
Knoten.setNext(Lesekopf);
System.out
.println("### Wenn Lesekopf dazwischen was einfuegen muss ###: "
+ Knoten.getValue());
}
} else {
// ### Wenn Liste Leer ist...
Knoten.setNext(null);
Knoten.setPrevious(null);
head = Knoten;
tail = Knoten;
System.out.println("### Liste war leer ###: " + Knoten.getValue());
}
}
/**
* Methode zum Entfernen von Werten aus einer Liste. Falls der uebergebene
* Wert mehrfach vorhanden ist, werden alle Vorkommen dieses Wertes aus der
* Liste entfernt
*
* @param T
* elem der zu entfernende Wert
*/
public void remove(T elem) throws EmptyStackException {
Node Lesekopf = head;
while (Lesekopf.getNext() != null && !empty()) {
if (Lesekopf.getValue() == elem) {
if (Lesekopf != head && Lesekopf != tail) {
Lesekopf.getNext().setPrevious(Lesekopf.getPrevious());
Lesekopf.getPrevious().setNext(Lesekopf.getNext());
//Lesekopf = tail;
break;
}
if (Lesekopf == head) {
Lesekopf = Lesekopf.getNext();
Lesekopf.setPrevious(null);
Lesekopf = head;
break;
}
if (Lesekopf == tail) {
Lesekopf.getPrevious().setNext(null);
Lesekopf = tail;
break;
}
} else {
if (empty()) {
System.out
.println("Nichts zu loeschen, weil die Liste leer, oder das gesuchte Element nicht vorhanden ist.");
break;
} else {
Lesekopf = Lesekopf.getNext();
}
}
}// Ende while-Schleife
}
/**
*
* Wenn Start und Endknoten NULL sind, so existiert auch keine Vorgaenger
* oder Nachfolger was bedeutet, dass die Liste leer ist.
*
* @return boolean
* */
public boolean empty() {
return ((head == null) && (tail == null));
}
/**
* Die Methode returnAll() gibt den gesamten Inhalt der gespeicherten
* Objekte zurueck
*
* @return nothing
*/
public void returnAll() {
Node Lesekopf = head;
while (Lesekopf.getNext() != null) {
Lesekopf = Lesekopf.getNext();
System.out.println(Lesekopf.getValue());
}
}
public static void main(String[] args) {
SortedList<Integer> stuff = new SortedList<Integer>();
System.out.println("Werte in Liste einbetten: ");
stuff.add(100);
stuff.add(101);
stuff.add(5);
stuff.add(3);
stuff.add(8);
System.out.println("Gespeicherte Werte ausgeben: ");
stuff.returnAll();
System.out.println("Etwas loeschen (8)... ");
stuff.remove(8);
stuff.returnAll();
System.out.println("Etwas loeschen (100)... ");
stuff.remove(100);
stuff.returnAll();
System.out.println("Etwas loeschen (101)... ");
stuff.remove(101);
stuff.returnAll();
System.out.println("Etwas loeschen (5)... ");
stuff.remove(5);
stuff.returnAll();
System.out.println("Ende des Programms.");
}
}Vieeelen Dank,
Semo
