Hallo zusammen,
für mein Studium muss ich eine doubleLinkedList Implementierung vervöllständigen. Der Prof hat uns hierfür einen Code zusammengestellt indem wir die Methoden, die mit TODO gekennzeichnet wurden vervollständigen sollen.
Folgender Code hat er uns bereit gestellt:
public class MyDoubleLinkedListEmpty {
private static class Node<T> {
Node<T> next; // Nächster Knoten (oder null)
Node<T> prev; // Vorheriger Knoten (oder null)
T element; // Referenz auf Datenelement
public Node(T el) {
element = el;
}
}
/**
* Anzahl der Elemente in Liste // wie viele dinge sind in gesamter liste
*/
private int size = 0;
// Referenz auf erstes Element (oder null)
private Node<T> start = null;
/**
* Liefert Node-Objekt an Position pos
*/
private Node<T> getNodeAt(int pos) {
if (pos >= size) throw new IllegalArgumentException();
Node<T> n = start;
for (;pos>0; pos--) {
n = n.next;
}
return n;
}
/**
* Liefert Node-Objekt an mit Element el.
* Falls Element nicht in Liste: Rueckgabewert null
*/
private Node<T> getNodeWithElement(T el) {
Node<T> n = start;
do {
if (n.element == el) return n;
n = n.next;
} while (n != null);
return null;
}
/**
* Fuege Element an Ende der Liste an
*/
public void add(T element) {
}
/**
* Fuege Element an Position pos (1. Element = Position 0) in Liste ein
*/
public void add(int pos, T element) {
// TODO
}
/**
* Loesche Liste
*/
public void clear() {
// TODO
}
/**
* Gibt true zurueck, wenn Liste das Element enthält
*/
public boolean contains(T element) {
if (element == n.element)
return false; // TODO
}
/**
* Gibt Element an Position pos zurück. Die Liste bleibt unveraendert.
*/
public T get(int pos) {
return null; // TODO
}
/**
* Ist die Liste leer?
*/
public boolean isEmpty() {
//TODO
return false;
}
/**
* Entfernt Knoten n aus Liste
*/
private T removeNode(Node<T> n) {
return null; // TODO
}
/**
* Entfernt Element element aus Liste. Falls Element in Liste gewesen: Rückgabewert true
*/
public boolean remove(T element) {
if (contains()) {
return true;
return false; // TODO
}
/**
* Entfernt Element an Position pos aus Liste. Gibt Referenz auf entferntes Element zurück
*/
public T remove(int pos) {
return null; // TODO
}
/**
* Anzahl der Elemente in Liste
*/
public int size() {
return 0; // TODO
}
}
}
Nun bin ich schon leider bei der ersten Methode am verzweifeln. Hat jemand eine Ahnung wieso hier ein Node<T> n = start implementiert wird und warum die int POS variable runterzählen soll und dabei n = n.next; sein soll!? Vorallem war mir nicht klar, dass diese Syntax überhaupt richtig ist mit "n = n.next" was bezweckt diese Zeile?
Ich bin neu hier und hoffe darauf, dass mir hier jemand helfen kann. Vielen Dank schon mal
für mein Studium muss ich eine doubleLinkedList Implementierung vervöllständigen. Der Prof hat uns hierfür einen Code zusammengestellt indem wir die Methoden, die mit TODO gekennzeichnet wurden vervollständigen sollen.
Folgender Code hat er uns bereit gestellt:
public class MyDoubleLinkedListEmpty {
private static class Node<T> {
Node<T> next; // Nächster Knoten (oder null)
Node<T> prev; // Vorheriger Knoten (oder null)
T element; // Referenz auf Datenelement
public Node(T el) {
element = el;
}
}
/**
* Anzahl der Elemente in Liste // wie viele dinge sind in gesamter liste
*/
private int size = 0;
// Referenz auf erstes Element (oder null)
private Node<T> start = null;
/**
* Liefert Node-Objekt an Position pos
*/
private Node<T> getNodeAt(int pos) {
if (pos >= size) throw new IllegalArgumentException();
Node<T> n = start;
for (;pos>0; pos--) {
n = n.next;
}
return n;
}
/**
* Liefert Node-Objekt an mit Element el.
* Falls Element nicht in Liste: Rueckgabewert null
*/
private Node<T> getNodeWithElement(T el) {
Node<T> n = start;
do {
if (n.element == el) return n;
n = n.next;
} while (n != null);
return null;
}
/**
* Fuege Element an Ende der Liste an
*/
public void add(T element) {
}
/**
* Fuege Element an Position pos (1. Element = Position 0) in Liste ein
*/
public void add(int pos, T element) {
// TODO
}
/**
* Loesche Liste
*/
public void clear() {
// TODO
}
/**
* Gibt true zurueck, wenn Liste das Element enthält
*/
public boolean contains(T element) {
if (element == n.element)
return false; // TODO
}
/**
* Gibt Element an Position pos zurück. Die Liste bleibt unveraendert.
*/
public T get(int pos) {
return null; // TODO
}
/**
* Ist die Liste leer?
*/
public boolean isEmpty() {
//TODO
return false;
}
/**
* Entfernt Knoten n aus Liste
*/
private T removeNode(Node<T> n) {
return null; // TODO
}
/**
* Entfernt Element element aus Liste. Falls Element in Liste gewesen: Rückgabewert true
*/
public boolean remove(T element) {
if (contains()) {
return true;
return false; // TODO
}
/**
* Entfernt Element an Position pos aus Liste. Gibt Referenz auf entferntes Element zurück
*/
public T remove(int pos) {
return null; // TODO
}
/**
* Anzahl der Elemente in Liste
*/
public int size() {
return 0; // TODO
}
}
}
Nun bin ich schon leider bei der ersten Methode am verzweifeln. Hat jemand eine Ahnung wieso hier ein Node<T> n = start implementiert wird und warum die int POS variable runterzählen soll und dabei n = n.next; sein soll!? Vorallem war mir nicht klar, dass diese Syntax überhaupt richtig ist mit "n = n.next" was bezweckt diese Zeile?
Ich bin neu hier und hoffe darauf, dass mir hier jemand helfen kann. Vielen Dank schon mal
