# LinkedList Methodenproblem



## nakertaa (19. Mai 2012)

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.


```
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;
  }
```


----------



## Firephoenix (20. Mai 2012)

Mal dir doch mal auf was bei deiner insert-Methode passiert:

Du erzeugst eine neue Liste, die zeigt mit ihrem next auf das next-feld der aktuellen liste.
Und dann setzt du next der aktuellen Liste auf die neue Liste -> ergibt einen schönen Ring, aber keine Linked List.

In length zerlegst du dir hiermit deine Liste:

```
tmp.next = tmp.next.next;
```
du setzt das next element auf das übernächste und "vergisst" es damit - das objekt wird gelöscht.

Was du eigentlich machen willst ist dein temporäres Feld zu überschreiben : tmp = tmp.next.

Ein Blatt Papier auf dem man sich mal aufmalt welche Objekte man hat, welche Speicherfelder von welchem Typ die haben und worauf die Speicherfelder wann zeigen hilft bei solchen Aufgaben imens.

Gruß


----------



## nakertaa (20. Mai 2012)

Danke die Length()-Methode funktioniert jetzt, allerdings scheint auch unsere equals-Methode falsch zu sein, wodurch auch andere Methoden nicht mehr funktionieren

Nochmal vielen Dank für die Hilfe.

Bzgl. der insert-Methode: Die ist also falsch? Wir haben sie nämlich eigentlich 1 zu 1 aus der Vorlesung so übernommen, dann könnte man sich ja nicht mal dadrauf verlassen.:noe:


----------



## Fant (20. Mai 2012)

In der equals-Methode solltest du eine übergebene LinkedList mit _this_ vergleichen


----------



## nakertaa (20. Mai 2012)

In der equals-Methode vergleichen wir ja das aktuelle Element, auf das der Zeiger zeigt (this.item) mit dem übergebenen x. In der find-Methode wird allerdings nichts verglichen, sondern einfach die komplette Liste anstatt der Teilliste ausgegeben. Wir kommen wohl nicht weiter, wie dort equals konkret auszusehen hat.


----------



## Landei (20. Mai 2012)

Außerdem hat die "richtige" equals-Methode die Signatur [c]boolean equals(Object o)[/c].


----------



## nakertaa (20. Mai 2012)

Die "richtige" equals-Methode haben wir von Object zu Element konvertiert. Daran kann es also (hoffentlich) nicht liegen.


----------



## Firephoenix (21. Mai 2012)

Habt ihr irgendwo definiert wann zwei listen equal sein müssen?
Bzw irgendwelche Tests dazu die fehlschlagen?

Hier jedenfalls mal tiefere Lektüre zu equals(): 
AngelikaLanger.com - Implementing the equals() Method - Part 2 - Angelika Langer Training/Consulting

Gruß


----------

