Hallo,
wir haben folgendes Problem und zwar möchten wir die Klasse LinkedList programmieren, die die diverse Methoden(z.B. delete() oder add()) enthält. Allerdings sind unsere Methoden length() und find() fehlerhaft, weswegen andere Methoden dann anscheinend auch nicht funktionieren (firstIndexof()). Obwohl length() beim einzelnen Aufruf den richtigen Wert ausgibt, wird bei einem nachfolgenden Aufruf von insert() nicht die alte Liste weitergeführt, sondern eine neue erzeugt.
Vielen Dank für jegliche Hilfe.
wir haben folgendes Problem und zwar möchten wir die Klasse LinkedList programmieren, die die diverse Methoden(z.B. delete() oder add()) enthält. Allerdings sind unsere Methoden length() und find() fehlerhaft, weswegen andere Methoden dann anscheinend auch nicht funktionieren (firstIndexof()). Obwohl length() beim einzelnen Aufruf den richtigen Wert ausgibt, wird bei einem nachfolgenden Aufruf von insert() nicht die alte Liste weitergeführt, sondern eine neue erzeugt.
Vielen Dank für jegliche Hilfe.
Java:
public class LinkedList implements List {
/**
* deklariert item
*/
private Element item;
/**
* deklariert next
*/
private LinkedList next;
/**
* erzeugt einen Konstruktor
*/
public LinkedList() {
item = null;
next = null;
}
/**
* initalisiert item
* @return item
*/
public Element getItem() {
return item;
}
public LinkedList getNext() {
return next;
}
/**
* Dies ist die isEmpty-Methode.
* @param Liste
* @return boolescher Wert, ob die Liste leer ist
*/
public boolean isEmpty() {
return next == null;
}
/**
* Dies ist die isInList-Methode.
* @param Liste
* @return boolescher Wert, ob x in Liste
*/
public boolean isInList(Element x) {
return (find(x) != null);
}
/**
* Dies ist die firstElement-Methode.
* @param Liste
* @return das erste Element
*/
public Element firstElement() {
if (isEmpty()) {
return null;
} else {
return next.item;
}
}
/**
* Dies ist die length-Methode.
* @param Liste
* @return die Länge des Feldes
*/
public int length() {
int zaehler = 0;
LinkedList tmp = this;
if (isEmpty()) {
return 0;
} else {
while (tmp.next != null) {
zaehler = zaehler+1;
tmp.next = tmp.next.next;
}
return zaehler;
}
}
/**
* Dies ist die insert-Methode.
* @param Liste
* @return die neue Liste mit neuem Anfangswert
*/
public LinkedList insert(Element x) {
LinkedList l = new LinkedList();
l.item = x;
l.next = next;
next = l;
return this;
}
/**
* Dies ist die append-Methode.
* @param Liste
* @return neue Teilliste mit neuem Endwert
*/
public LinkedList append(Element x) {
if (isEmpty()) {
return insert(x);
} else {
add(x, length() + 1);
return this;
}
}
/**
* Dies ist die find-Methode.
* @param Liste
* @return Teilliste mit dem gefundenen Element
*/
private LinkedList find(Element x) {
LinkedList tmp = this;
for (int i = 0; i < length(); i++) {
tmp = tmp.next;
if (x.equals(this.item)) {
break;
}
}
return this;
}
/**
* Dies ist die delete-Methode.
* @param Liste
* @return neue Liste mit entferntem ersten x
*/
public LinkedList delete(Element x) {
LinkedList tmp = null;
for (int i = 0; i < length(); i++) {
tmp = this.next;
if (x.equals(this.item)) {
tmp = this.next.next;
}
}
return this;
/*LinkedList l = find(x);
if (l != null) {
l.next = l.next.next;
}
return this;*/
}
/**
* Dies ist die delete-Methode.
* @param Liste
* @return neue Liste mit entferntem erstem Element
*/
public LinkedList delete() {
if (!isEmpty()) {
next = next.next;
}
return this;
}
/**
* Dies ist die add-Methode.
* @param Liste
* @return neue Liste mit neuem x an Stelle n
*/
public LinkedList add(Element x, int n) {
if (n > this.length()) {
throw new IllegalArgumentException ("Die Liste enthaelt weniger als "+n+"Elemente!");
}
LinkedList tmp = this;
for (int i = 0; i < n - 1; i++) {
tmp = tmp.next;
}
LinkedList l = new LinkedList();
l.item = x;
l = tmp.next;
tmp = l;
return this;
public int firstIndexOf(Element x) {
LinkedList tmp = this;
for (int i = 0; i < length(); i++) {
tmp = tmp.next;
if (x.equals(this.item)) {
return i;
break;
}
}
return -1;
}
}
public boolean equals (Element x) {
return x == this.item;
}
Zuletzt bearbeitet: